rust.md

title
Rust

Rust

Rust Book & Rust in Action are great. Rust for JS Devs & Zero To Prod (good notes) are nice too. You can also use this brief starter guide.

Templates

• Rust Service Template

OSS Rust websites

• emojied - Fast URL shortener that uses emojis, only emojis. (What I learned)

Notes

• Note that cargo check is faster than doing a full compile. Also I use the rust-analyzer language server for IDE integration to catch errors as I write them. Between the two, my workflow usually avoids the need for actually compiling a binary until I'm ready to run tests.
• Every reference in Rust has a lifetime, but the compiler is usually smart enough to infer it.
• Rust's key feature - the borrow-checker - relies on the idea that each value has a single "owner" at any given time. This owner can be a function, another value (a parent struct), etc. You can put these values on the heap, but if you use Box (the go-to for heap allocation), that pointer still has to have a single logical "owner". Under idiomatic Rust, each value effectively lives in one single "place". This allows the compiler to determine with 100% confidence at what point it's no longer being used and can therefore be de-allocated.
  • Now, these values can be lent out ("borrowing") to sub-functions and such via references (mutable or immutable). Multiple immutable references can be handed out at once, but a mutable reference to a value has to be the only reference to that value of any kind, at a given time.
• My go to for Rust actors package is usually tokio::sync::mpsc and tokio::spawn.
• For error handling: We use anyhow for applications, thiserror for libraries.
• Once you internalize Rust's concept of ownership and its criticality to memory safety, it forever changes how you look at C/C++ code. You will constantly be amazed - and demoralized - by how often C/C++ code doesn't document memory lifetimes/ownership in its API contracts.
• Rust enums are amazing. They are also known as Sum Types.
• If you're building a database , OS, or other systems-level infrastructure, choose Rust. If you're not building those things, choose not-Rust. Rust is the better C we've all been hoping for. But most companies have no business writing programs in C, or even in a better C.
• If you are starting learning Rust, try to follow this rule of thumb: only owned types in fields of your own types, always return owned values unless you're passing through directly from a function argument, clone liberally, derive(Copy) when possible, use Arc/RefCell to unblock.

Links

• Rust language book (Code) (Exercises code)
• Rust by Example
• Rust Language Reference (Code)
• Rust Code
• Idiomatic rust
• Rust patterns
• Reflections on Rust, and the Sand Castle Metaphor
• Building Reliable Infrastructure in Rust by Tyler Neely
• Rust in production at Figma
• Category Theory in Rust Notes
• Cargo generate - Developer tool to help you get up and running quickly with a new Rust project by leveraging a pre-existing git repository as a template.
• Rust Won't Save You From All Bugs
• Desktop and editor setup for Rust development (2018)
• Rust can be difficult to learn and frustrating, but it’s also the most exciting thing in software development in a long time (2018)
• Parsing logs 230x faster with Rust (2018)
• Cross - "Zero setup" cross compilation and "cross testing" of Rust crates.
• Vim setup for Rust
• Cargo Watch - Watches over your Cargo project's source.
• Rust Programming Language Forum
• List of Rust bloggers
• Jon Gjengset YouTube channel - Does many awesome Rust streams.
• The What and How of Futures and async/await in Rust
• Introducing Rust crash course (2018)
• Rust Language Cheat Sheet (HN) (HN 2) (Code)
• Rerast - Tool for transforming Rust code using rules.
• Rust Runtime for AWS Lambda - Makes it easy to run AWS Lambda Functions written in Rust.
• cargo-inspect - What is Rust doing behind the scenes?
• Scale By The Bay 2018: Bryan Cantrill, Rust and Other Interesting Things - Good talk on importance of values in programming languages.
• cargo-call-stack - Whole program static stack analysis.
• Rust in 2022 (2018)
• Rust 2019: Think Bigger (2018)
• Rust Analyzer - Experimental Rust compiler front-end for IDEs. (Web) (Architecture) (Notes)
• Rust at speed — building a fast concurrent database (2018)
• You can't Rust that (2018)
• Rust Playground - Run Rust code online. Code. (HN)
• crates.io - Source code for crates.io
• Read Rust - Collects interesting posts related to the Rust programming language.
• A Quick Look at Trait Objects in Rust (2019)
• Teach Rust (2019) - Free workshop material to use to give a course introducing the Rust programming language.
• Moving from Ruby to Rust (2019) (HN)
• miniserve - Nice & small CLI tool in Rust (can use for inspiration in building Rust CLI tools).
• Rust: A unique perspective (2019)
• Minimizing Rust Binary Size
• Rust Programming Tipz
• Rustlings - Small exercises to get you used to reading and writing Rust code. (Solutions)
• Learn Rust With Entirely Too Many Linked Lists (Lobsters) (HN)
• cargo audit - Audit Cargo.lock files for crates with security vulnerabilities.
• Changelog generator for Rust projects
• Rust: Frequently Asked Questions
• Building fast interpreters in Rust (2019)
• Rust RFCs (Code) (Book)
• 2019 Roadmap for Rust
• Rust RFCs
• Learning Rust - Materials for learning Rust. (Code)
• Rust types cheat sheet (Code)
• Rust Cookbook - Collection of simple examples that demonstrate good practices to accomplish common programming tasks, using the crates of the Rust ecosystem. (Code) (HN)
• hello-rust - Simple hello world in Rust, with a Nix environment.
• A final proposal for await syntax (2019) (HN) (Lobsters)
• Sealed Rust (2019)
• Async Rust Programming Book
• Best short-form writing about Rust, collected
• Update on await syntax (HN)
• Sonny Scroggin - BEAM + Rust: A match made in heaven (2019)
• Collection of software engineering techniques for effectively expressing intent with Rust
• What are the most important traits to learn in the rust stdlib? (2019)
• Rust API guidelines - Set of recommendations on how to design and present APIs for the Rust programming language.
• The Go Developer's Quickstart Guide to Rust (2018)
• Notes on a smaller Rust (2019) (Lobsters)
• Functional Programming Jargon in Rust
• MIRAI - Rust mid-level IR Abstract Interpreter.
• Are we async yet?
• A static web app in Rust (2018)
• Rust from a Java dev (2015)
• Announcing Rust 1.37.0 (2019) (HN)
• Awesome Rust
• cargo-bloat - Find out what takes most of the space in your executable.
• Rust CLI working group
• C2Rust - Migrate C code to Rust. (Web) (HN) (C2Rust is Back)
• cargo-play - Tool to help you running your Rust code file without manually setting up a Cargo project.
• [cargo-]flamegraph - Easy flamegraphs for Rust projects and everything else, without Perl or pipes.
• Analysis of various tricky Rust code
• Falling in love with Rust (2018)
• Rust for JavaScript peeps
• Graphical depiction of ownership and borrowing in Rust (2017)
• Summary of the Rust book
• Cargo-sweep - Cargo subcommand for cleaning up unused build files generated by Cargo.
• cargo-udeps - Find unused dependencies in Cargo.toml
• Rust in Production at Figma (2018)
• Elegant Library APIs in Rust (2016)
• QuiCLI - Quickly build cool CLI apps in Rust.
• Making the Tokio scheduler 10x faster (2019)
• Why would a python programmer learn rust when there are no jobs in it (2019)
• How to not rewrite it in Rust (2019) (HN)
• Guide to Rustc Development
• Corrode - Automatic semantics-preserving translation from C to Rust.
• Ferrous Systems - Provide consulting and made-to-measure solutions based on our expertise in Rust programming.
• Rust for C++ developers - What you need to know to get rolling with crates - Pavel Yosifovich (2019)
• rustfmt - Format Rust code.
• Rust API guidelines - Set of recommendations on how to design and present APIs for the Rust programming language.
• pprof - Rust cpu profiler implemented with the help of backtrace-rs.
• Using Rust (2019)
• Cargo - Rust package manager.
• Async-await on stable Rust! (2019) (HN)
• Comparing Parallel Rust and C++ (HN)
• Rust web framework comparison
• Rust memory management explained from C perspective (2019)
• What makes rust so fast? (2019)
• Rust Playground for macOS - Standalone native mac application that allows quickly editing and testing rust snippets.
• Command line apps in Rust (HN)
• Polonius (the future Rust borrow checker) talk at Rust-Belt-Rust 2019 - Nicholas Matsakis (Reddit)
• Rust Performance Pitfalls (2017)
• This Week in Rust Newsletter (Code)
• Are we learning yet? - Work-in-progress to catalog the state of machine learning in Rust. (Code)
• Neat Rust Tricks: Passing Rust Closures to C (2019) (HN)
• now-rust - Community based builder for using rust on the now/zeit platform.
• Sean Grove: Rust in the Browser for JavaScripters:New Frontiers,New Possibilities (2019)
• How to rewrite it in Rust
• Taking ML to production with Rust: a 25x speedup (2019)
• Is It Time to Rewrite the Operating System in Rust?
• PingCAP Style Guide - Guide to writing idiomatic code at PingCAP and in the TiKV project.
• Declarative UI Patterns in Rust (2019)
• Speeding Up the Rust Compiler (2019) (HN)
• From zero to main(): Bare metal Rust (2019) (HN)
• Learn Rust the Dangerous Way (HN)
• Rewriting m4vgalib in Rust (2019)
• Papyrus - Rust REPL.
• Actix Web: Optimization Amongst Optimizations (2020)
• Translating Quake 3 into Rust (2020)
• Let The Compiler Do The Work (2020) (HN) (Reddit)
• Why Rust? I have a GC! (2020) (Reddit)
• Rust Database Connectivity (RDBC) (2020) (HN)
• Rust: Unlocking Systems Programming (2016)
• Hello Rust - Lighthearted live-programming channel about my journey to become a fearless, more effective Rust programmer.
• Introduction to Rust (for people who have never used a compiler)" - Tim McNamara (2020)
• Rust in Action Book (2020) (Code) (Web)
• How To Write Fast Rust Code (2020) (Reddit)
• The Soundness Pledge (2020) (Reddit)
• What is Rust and why is it so popular? (2020) (HN)
• cargo-generate - Developer tool to help you get up and running quickly with a new Rust project by leveraging a pre-existing git repository as a template.
• cargo-make - Rust task runner and build tool.
• Sealed Rust Update (2020)
• Cargo bundle - Wrap Rust executables in OS-specific app bundles.
• Why Rust, or a Trip Report from My Satori with Rust and Functional Programming (2020) (HN) (Lobsters)
• Working with strings in Rust (2020) (Lobsters)
• bindgen - Automatically generates Rust FFI bindings to C (and some C++) libraries.
• A half-hour to learn Rust (2020) (HN) (HN 2)
• Rust Ownership Rules (2020) (HN)
• Considering Rust (2020)
• async-on-embedded - On embedded (Cortex-M edition): no-global-alloc, no-threads runtime.
• Rust And C++ On Floating-Point Intensive Code (2019) (HN)
• Tarpaulin - Code coverage tool for Rust projects.
• Out of the Box Dynamic Dispatch (2020)
• Optimizations That Aren't, Or Are They? (2020)
• How I Start: Rust (2020) (HN)
• Rust Books
• Lobsters: Yes, I am still learning Rust (2020)
• Guide on how to write documentation for a Rust crate (2020) (HN)
• HN: Apple is looking for engineers to convert its code from C to Rust (2020)
• Rust Design Patterns
• Rust Design Patterns as a Book (HN)
• Guide to Rustc Development (Code)
• Rust For Systems Programmers
• Rust Latam: procedural macros workshop
• Shipping a compiler every six weeks (2019) (HN)
• Prefer Rust to C/C++ for new code (2019) (HN)
• Understanding Serde (2019) (HN)
• Rust 2020: GUI and community
• Typestates in Rust (2018) (HN)
• State Machines in Rust (2020) (HN) (Lobsters)
• explaine.rs - Interactive Rust syntax playground. (Code)
• Rustonomicon - Dark Arts of Advanced and Unsafe Rust Programming. (Code) (HN)
• Rust DataFrame - Rust DataFrame implementation, built on Apache Arrow. (HN)
• Error Handling in a Correctness-Critical Rust Project (2020) (Lobsters)
• I can't keep up with idiomatic Rust (2020) (HN) (Reddit) (Lobsters)
• Prusti - Static verifier for Rust, based on the Viper verification infrastructure.
• Mental models around Ok-Wrapping (2020) (HN)
• Canduma rust authentication server boilerplate - Rust Boilerplate server with GraphQL API, Diesel, PostgreSQL, session authentication and JWT.
• Rust teams structure
• Rust Learning - Bunch of links to blog posts, articles, videos, etc for learning Rust.
• How often does Rust change? (2020) (Lobsters) (HN) (HN 2)
• Cranelift backend for rustc
• Possible New Backend for Rust (2020)
• Ask Rust Experts
• Writing Python inside your Rust code (2020) (HN) (Reddit)
• Debugging Rust in VSCode (2020)
• Building a JS Interpreter in Rust (2018)
• HN: Rust Survey 2019 Results
• Rust language design team notes
• Rust Stream: Ownership, Closures, and Threads (2020)
• Awesome Rust Streaming
• Ferrous' Rust Experts Q&A - Contributing to Rust (2020)
• Notes on Parsing in Rust (2020) (Lobsters)
• Thread on Rust: what I like and what not (2020)
• Screencast on writing Snabb in Rust (2020)
• From Rust to WebAssembly: building an interactive note-taking webapp with Actix & Yew (2020)
• Async interviews: my take thus far (2020)
• How we use Rust in our mobile SDK (2020) (HN)
• Rust language interoperability with other languages - C, C++ etc
• Making rust as fast as go (HN)
• Rust Koans
• Naive NixOS Rust Development (2020)
• Auto-currying Rust Functions (2020)
• HN: Re: Integrating "safe" languages into OpenBSD? (2017)
• Using Rust to Power Python Importing With oxidized_importer (2020)
• Learning Rust in 2020 (HN)
• Guide to Global Data in Rust
• Getting Started with Rust by Building a Tiny Markdown Compiler (2019) (HN)
• Rust Analyzer: Next Few Years (2020) (Reddit)
• Things I hate about Rust (2020) (HN)
• rust-cross - Everything you need to know about cross compiling Rust programs.
• Rust verification tools (2020) (Lobsters) (Code)
• Common Rust Lifetime Misconceptions (HN)
• Rust's Runtime (2020) (Lobsters)
• Integration Testing in Rust (2020)
• Lifetime variance in Rust - Covers the basics of variance in Rust, as it applies to lifetimes, written in a literate programming style.
• Rust's Unsafe Code Guidelines (Code)
• Open Data Structures (in Rust)
• trait-eval - Play FizzBuzz at compile-time.
• muslrust - Docker environment for building musl based static rust binaries.
• Coverage Marks (2020)
• Rust: Dropping heavy things in another thread can make your code 10000 times faster (2020) (HN) (Lobsters)
• Rust as a High Level Language (2020)
• Tour of Rust - Tour of rust's language features. (Code) (HN)
• Awesome Rust Mentors (Code)
• Why the developers who use Rust love it so much (2020) (HN)
• Learn Rust with TDD (Code)
• Zero To Production #1: Setup - Toolchain, IDEs, CI (2020)
• New inline assembly syntax available in nightly (2020) (HN) (Reddit)
• Asynchronous Programming in Rust (Code)
• Shredder: Garbage Collection as a Library for Rust (2020) (Code) (Lobsters)
• Errors in Rust: A Deep Dive (2020)
• Generics and Compile-Time in Rust (2020) (HN)
• The Rust compiler isn't slow; we are. (2020) (Lobsters)
• 3K, 60fps, 130ms: achieving it with Rust (2020) (HN)
• Understanding the Rust Ecosystem (2020)
• Call for help implementing an independent Rust frontend for GCC
• Tips for Faster Rust Compile Times (2020)
• Rust: the archetype of a message-passing bug (2020) (HN)
• Rust's Huge Compilation Units (2020) (HN)
• Rust for JavaScript Developers - Tooling Ecosystem Overview (2020)
• On Rust Lifetimes (2019)
• A Few More Reasons Rust Compiles Slowly (2020) (HN)
• Context-preserving error handling (2020)
• Back to old tricks, or, baby steps in Rust (2020) (HN)
• Choosing a Rust web framework (2020) (HN)
• Rust is Surprisingly Good as a Server Language (2020) (HN) (Lobsters)
• caniuse.rs - Rust feature search. (Code)
• Building and debugging a high-throughput daemon in Rust (2020)
• Why even unused data needs to be valid (2020) (Reddit)
• Two Beautiful Rust Programs (2020) (Reddit)
• Rust for JavaScript Developers - Pattern Matching and Enums (2020) (HN)
• Shipping Const Generics in 2020 (HN)
• Rust 1.45 (2020) (HN)
• Clear explanation of Rust’s module system (2020) (Lobsters)
• Enum or Trait Object (2020) (Lobsters)
• Possible Rust - Learning what’s possible in Rust.
• Rust explained using easy English (HN) (Lobsters)
• Berline.rs - Berlin-local Rust community.
• Blue Team Rust: What Is “Memory Safety”, Really? (2020) (HN)
• A gentle intro to assembly with Rust (2020)
• Learning Rust: Mindsets and Expectations (2020)
• An introduction to Data Oriented Design with Rust (2020) (HN)
• Rusty Days 2020
• Inbound & Outbound FFI (2020)
• How to speed up the Rust compiler some more in 2020 (HN) (Lobsters)
• Crust of Rust: Channels (2020)
• Rust at Sunrise - Daily update on the latest Rust Nightly. (Code)
• Rust Compiler Performance Monitoring & Benchmarking (Code)
• Surviving Rust async interfaces (2020) (Lobsters)
• Rust for a Pythonista (2020)
• Two Years With Rust (2020)
• sled theoretical performance guide - Covers timeless ideas that are helpful to keep in mind while working with systems where performance matters. (Lobsters)
• rd - Record/replay debugger written in rust.
• "Rust does not have a stable ABI" (Lobsters) (HN)
• I am a Java, C#, C or C++ developer, time to do some Rust (2020)
• Frustrated? It's not you, it's Rust (2020) (Lobsters) (Reddit)
• Error recovery with parser combinators (using nom) (2020)
• Comparative unsafety (2020) (Lobsters)
• Learning Rust: The Compiler is your Friend (2020)
• Existential types in Rust (2018) (Lobsters)
• Ryan Levick - Why should I care about Rust? (2020)
• Makepad - Creative software development platform built around Rust. (Code) (Code)
• Jon Gjengset Q&A August 2020
• Laying the foundation for Rust's future (2020) (HN (Lobsters))
• Run Rust on your embedded device from VSCode in one click (2020)
• Practical Networked Applications in Rust, Part 1 (2019) (Part 2)
• Rust and C++ Interoperability in Chrome (2020) (HN)
• Rust Unstable Book
• First thoughts on Rust vs OCaml (2020) (Lobsters) (HN)
• In Rust, ordinary vectors are values (2018)
• RustConf 2020 Summary (HN)
• Using C libraries in Rust: make a sys crate
• Different levels of async in Rust (2020)
• Rust Memory Container Cheat-sheet
• HN: Rust 1.46 (2020) (Lobsters)
• Acheiving warp speed with Rust (2017)
• Inviting God's Wrath with Cursed Rust (2020)
• Supporting Linux kernel development in Rust (2020) (HN)
• Rust testing or verifying: Why not both? (2020) (HN)
• Understanding and Evolving the Rust Programming Language (2020) (Reddit)
• If you want performance, cheat (2020)
• C++ vs Rust: an async Thread-per-Core story (2020)
• Peeking inside a Rust enum (2020)
• From Rust to TypeScript (2020)
• My Favorite Rust Function Signature (2020) (HN)
• Why Not Rust? (2020) (Lobsters) (HN) (HN)
• My least favorite Rust type (2020) (HN) (Lobsters) (Reddit)
• Resources to help you get started with Rust (2020)
• Neovim and Rust (2020) (Reddit)
• Building even faster interpreters in Rust (2020)
• Rust Crates that do What the Go Standard library Does (2020) (Lobsters)
• Learning Rust the Open Source Way (2020)
• Clippy - Collection of lints to catch common mistakes and improve your Rust code.
• Rust 2021: GUI (2020) (HN)
• Speed of Rust vs C
• The First-Mover Allocator Pattern (2020)
• The Typestate Pattern in Rust (2019)
• Revisiting a 'smaller Rust' (2020) (Lobsters)
• Optimization - Making Rust Code Go Brrrr (2020)
• Safely mixing Rust and OCaml in the TezEdge node (2020)
• Rust Web Boilerplate - Rust web template for modern web backend applications.
• A Fistful of States: More State Machine Patterns in Rust (2020)
• Rust lets us monitor 30k API calls/min (2020) (HN)
• Rust Starter Kit 2020 (HN)
• Drop order in Rust: It's tricky (2020)
• Type-level Programming in Rust (2020) (HN)
• Dancing Links In Rust (2020)
• Designing a New Rust Class at Stanford: Safety in Systems Programming (2020) (HN)
• CS 110L: Safety in Systems Programming (2020) (Code)
• Rust async execution (2019)
• Rust Async Benchmark - Attempts to compare the performance of a manually written poll loop vs async/await.
• Constant Evaluation Rust Proposals
• A New Back End for Cranelift (2020) (HN)
• Rust After the Honeymoon (2020) (HN) (Lobsters)
• Learning Rust through open source and live code reviews (2020)
• Memory safe ‘curl’ for a more secure internet (2020) (Lobsters) (HN)
• Code Smell: Concrete Abstraction (2020)
• Optional parameters in Rust (2020)
• Docker+Rust Buildcache - Two strategies to cache rust builds within docker in the minimal example repo.
• A Few Github Action “Recipes” for Rust (2020)
• “Tear”able Puns, and Worse Ideas: A Minimally Thread-Safe Cell (2020)
• Layouts and dealloc: An unfortunate aspect of Rust’s allocation API (2020)
• Collect in Rust, traverse in Haskell and Scala (2020)
• Are out parameters idiomatic in Rust? (Lobsters)
• warp-api-starter-template - Boilerplate template for starting a web services using Warp + SQLx (PostgreSQL) + Redis + Juniper (GraphQL).
• Neovim and Rust (2020)
• Learn Rust
• Fighting Rust's Expressive Type System (2020)
• Ungrammar - DLS for specifying concrete syntax tree. (Article) (HN)
• RustFest - Rust community conference. (Blog) (Code)
• Rust Compiler Team - Home for compiler team planning documents, meeting minutes, and other such things. (Code)
• Rust Careers - Find your next Rust job.
• Rust for Data-Intensive Computation (2020)
• cargo-chef - Cache the dependencies of your Rust project and speed up your Docker builds. (Article)
• Zero To Production In Rust - Opinionated introduction to backend development. (Code) (HN) (Code) (Notes)
• So you want to write object oriented Rust (2020)
• A practical guide to async in Rust (2020)
• Why Dark didn't choose Rust (2020) (Lobsters) (HN)
• The Fatal Flaw of Ownership Semantics (2020) (HN)
• Error Handling in Rust (2015)
• Rust Forge - Information useful to people contributing to Rust. (Code)
• Exploring PGO for the Rust compiler (2020)
• Managing Rust bloat with Github Actions (2020)
• Rust Performance Book (Code) (HN)
• Rust Search Extension - Search docs, crates, builtin attributes, official books, and error codes, etc in your address bar instantly. (Code)
• 40 Ms Bug (2020) - Small story about tracking down a production bug in a Rust application. (Lobsters)
• Demystifying Asynchronous Rust (Code)
• Rust Language Design Team - Language design team is generally responsible for decisions involving the design of the Rust language itself, such as its syntax, semantics, or specification. (Code)
• The Usability of Ownership in Rust (2020)
• A Cool Generic Concurrency Primitive in Rust (2020)
• Rust Error Handling Project Group
• Rust Website Code
• Writing Rust the Elixir way (2020) (Lobsters)
• Futures Explained in 200 Lines of Rust (Code)
• bacon - Background rust code check.
• Inside Rust at Embark (2019)
• Deploy Rust lambda functions on Netlify
• Understanding Partial Moves in Rust (2020) (Lobsters)
• rustfix - Automatically apply the suggestions made by rustc.
• Rust Iterator Cheat Sheet
• Aiming for correctness with types (2020) (Lobsters)
• Pointers Are Complicated II, or: We need better language specs (2020) (HN)
• Pointers Are Complicated III, or: Pointer-integer casts exposed (2022) (HN)
• Embark Rust Ecosystem - High-level tracking and discussions about improving Rust and the Rust ecosystem for our game development use cases at Embark.
• Problems with building backend app in Rust in 2020
• Build your own async primitive (2020) (HN)
• Rust Prehistory Repo
• Rust is now overall faster than C in benchmarks (2021) (HN)
• The Rust module system for Python users (2021)
• GCC Rust - GCC Front-End for Rust. (Web) (HN)
• Oxide: The Essence of Rust (Code)
• Rust: Structuring and handling errors in 2020 (HN)
• Rust is a hard way to make a web API (2021) (HN) (Lobsters)
• Rust GUI: Introduction, a.k.a. the state of Rust GUI libraries (2021)
• rust-starter - Simple framework to build Rust CLI Applications. (Web) (GitHub) (HN)
• Rust Companies - Curated list of companies using Rust in production, organized by industry.
• rust-nix-templater - Generates Nix build / dev files for Rust projects.
• How to Read Rust Functions (2021)
• Async Rust: Futures, Tasks, Wakers; Oh My! (2021)
• Rust Foundation - Independent non-profit organization to steward the Rust programming language and ecosystem. (Hello World) (HN) (Lobsters)
• Comparison of Rust async and Linux thread context switch time and memory use (HN)
• A New Backend for Cranelift, Part 1: Instruction Selection (2019) (Part 2)
• For the Love of Macros (2021)
• Command Line Applications in Rust Book (Code) (Code)
• Rust CLI Project Template - Base project template for comfortably building small but reliable utilities in the Rust programming language.
• Implementing flat_map in Rust (2020)
• Ask the Expert: Rust at Microsoft (2021)
• Integrating Rust and C++ in Firefox (2021)
• Rust for web development: 2 years later (2021) (HN)
• Rust Fuzzing Book - Guides and tutorials on how to fuzz Rust code. (Code)
• Macros in Rust: A tutorial with examples (2021)
• Rust const generics MVP hits beta (2021) (HN)
• Life in Differential Dataflow (2021)
• Rust Incubator - Learning Rust step-by-step.
• Awesome Embedded Rust
• RustViz - Interactively Visualizing Ownership and Borrowing. (HN)
• How to speed up rustdoc in 2021
• Getting started with ... Rust (2021)
• totally_safe_transmute, line-by-line (2021) (Lobsters)
• Building a shared vision for Async Rust (2021) (Lobsters) (HN)
• Safe Systems Programming in Rust (2021)
• How to execute shellcodes from memory in Rust (2021)
• Fireflowers - The Rust Programming Language, in the words of its practitioners
• Pin and suffering (2021)
• Where to go to learn Rust in 2021 (HN) (Lobsters)
• The magical applications of Zero-Sized Types in Rust (2021)
• Learning Parser Combinators With Rust (2019)
• Parser combinators in Rust (2021)
• Crust of Rust: Atomics and Memory Ordering (2021) (Reddit)
• Rust generics vs Java generics (2019)
• Debug Formatters in Rust (2021)
• Mutabah's Rust Compiler - Alternative rust compiler (re-implementation).
• rust-overlay - Pure and reproducible nix overlay for binary distributed rust tool chains.
• Tour of Rust's Standard Library Traits (2021)
• Creusot - Tool for deductive verification of Rust code.
• Rustexp - Rust regular expression editor & tester. (Code)
• Best of ML Rust - Ranked list of awesome machine learning Rust libraries.
• Rust for {Ruby, Haskell, C, ...} programmers
• Priroda - Graphical debugger for Rust MIR.
• Ferrous Rust Teaching Material (Web)
• Rust shenanigans: return type polymorphism (2021) (Lobsters)
• Why Rust strings seem hard (2021) (HN) (Lobsters)
• du it in Rust: async, tokio, streams, and surprises about perf (2021)
• What's in the box? (2021) (Lobsters) (HN)
• First steps with Rust (HN) (Videos) (HN)
• IRust - Cross Platform Rust REPL.
• If you could re-design Rust from scratch today, what would you change? (2021) (Lobsters)
• Red & blue functions are actually a good thing (2021) (HN)
• Async programming in Rust | A video essay (2021)
• A brief history of Rust at Facebook (2021) (HN)
• Building an Emulator with Rust
• Why asynchronous Rust doesn't work (2021) (HN) (HN)
• Rust's Most Unrecognized Contributor (2021) (Lobsters) (Reddit)
• xargo - Sysroot manager that lets you build and customize std.
• cargo-xbuild - Automatically cross-compiles the sysroot crates core, compiler_builtins, and alloc.
• Understanding Rust as a C++ developer (2021)
• Programming Rust Book (2021) (GitHub) (Reddit)
• An Incomplete Explanation of the Proc Macro That Saved Me 4000 Lines of Rust (2021)
• The Great Rewriting In Rust (2021)
• Moves, copies and clones in Rust (2020) (Lobsters)
• Interior mutability in Rust: what, why, how? (2016)
• Optimizing 700 CPUs Away With Rust (2021) (Tweet)
• A primer on code generation in Cranelift (2021)
• flapigen-rs - Tool for connecting programs or libraries written in Rust with other languages.
• refcounts (2021)
• The Plan for the Rust 2021 Edition (HN)
• 55,000 lines of Rust code later: A debugger is born (2021) (HN)
• Medium to hard Rust questions with explanations (Code)
• Rust Weird Expressions (HN)
• Things you can’t do in Rust (and what to do instead) (2021) (Reddit) (HN)
• Debugging rust application inside Linux container (2021)
• Naming Your Lifetimes (2021)
• Rust Web Development (2021) (Reddit) (Code)
• Rust books you read and liked? (2021)
• mutagen - Breaking your Rust code for fun & profit.
• Awesome Rust Security
• Writing Pythonic Rust (2021) (HN)
• Routing traffic in Rust using eBPF (2021)
• Rust is a wave of the future (2021) (Lobsters) (HN)
• Awesome Rewrite It In Rust - Curated list of replacements for existing software written in Rust. (Reddit) (HN) (Lobsters)
• Structural Typing in Rust (2021)
• My first cup of Rust (2021) (Lobsters)
• My second cup of Rust (2021)
• Puffin - Simple instrumentation profiler for Rust.
• The simpler alternative to GCC-RS (2021)
• RPG - CLI tool for the Rust Playground.
• Tightness Driven Development in Rust (2021)
• A Firehose of Rust, for busy people who know some C++ (2021)
• Rust for Rustaceans Book (2021) - Idiomatic Programming for Experienced Developers. (Tweet) (Web) (Web Code)
• vergen - Generate cargo: instructions at compile time in build scripts for use with the env! macro.
• Build your own X in Rust
• Automatic Rust verification tools (2021)
• From Julia to Rust (2021) (HN)
• Crust of Rust - YouTube - Video series to understand intermediate Rust concepts.
• Sizedness in Rust (2020)
• Untapped potential in Rust's type system (2021) (HN)
• Exploring ways to make async Rust easier (2021)
• A Tour of Safe Tracing GC Designs in Rust (2021) (HN)
• Rust is not a Company (2021) (HN)
• Type-checked keypaths in Rust (2021) (Lobsters)
• Polymorphism in Rust (2021)
• Hands-on Rust Book (2021) - Effective Learning through 2D Game Development and Play. (Code) (HN)
• What Can Coerce, and Where, in Rust (2021)
• Compiling Rust is NP-hard (2021) (HN) (Lobsters)
• Inline In Rust (2021) (Lobsters)
• The problem of effects in Rust (2020) (Lobsters)
• How we improved the performance of our Rust app (2021)
• Rust in Motion
• Understanding Rust futures by going way too deep (2021) (HN)
• Awesome Unstable Rust Features (2021) (Reddit)
• Async/Await - The challenges besides syntax - Cancellation (2019) (Lobsters)
• Rust on GraalVM using bitcode (2020)
• First steps with Rust declarative macros (2021)
• Mutable statics have scary superpowers! Do not use them (2021)
• Dealing with Out-of-Memory Conditions in Rust (2021) (HN)
• My Rust development workflow (after 2+ years) (2021)
• How to create small Docker images for Rust (2021)
• Black Hat Rust Book (Code) (Bonuses)
• How to write slow Rust code (2021) - How I tried to port Lisp code to Rust and managed to get a much slower program. (HN)
• Rust Cryptography Interest Group (RCIG) - Coordination repo for all things Rust Cryptography oriented.
• Rust Cloud Native - Collection of resources about cloud native Rust. (Code) (HN)
• wg-async-foundations - Working group dedicated to improving the foundations of async I/O in Rust. (Code)
• When Zero Cost Abstractions Aren’t Zero Cost (2021) (Reddit) (HN)
• Rudra - Static analyzer to detect common undefined behaviors in Rust programs. (Paper)
• I probably didn't backdoor this: Using Reproducible Builds to verify a Rust binary -
• Index 1.6B Keys with Automata and Rust (2015) (HN)
• Rust API Guidelines Checklist - Guidelines that the Rust language standard library holds itself too. (HN)
• Large Rust Workspaces (2021) (Lobsters)
• Rust for JS Developers
• Awesome Rust Formalized Reasoning
• Writing Interpreters in Rust: a Guide (Code)
• Cargo B(inary)Install - Binary installation for rust projects.
• Optimizing Immutable Strings in Rust (2021)
• Hexagonal architecture in Rust (2021) (Code)
• Using SIMD acceleration in rust to create the world’s fastest tac (2021) (Lobsters)
• Virtual Machine Dispatch Experiments in Rust (2017)
• Systems Programming with Rust Book (2022) (Code)
• Fast Rust Builds (2021) (HN) (Reddit)
• An Alternative Syntax for Async Functions (2021) (Reddit)
• Multiple defining uses of Type Alias Impl Traits (2021)
• Writing software that’s reliable enough for production
• Rust programs written entirely in Rust (2021) (HN) (Code)
• Rust: Enums to wrap multiple errors (2021) (HN)
• The Why and How of Rust Declarative Macros (2021)
• Plugins in Rust: Getting Started (2021)
• How to avoid lifetime annotations in Rust (and write clean code) (2021) (Lobsters)
• I/O safety and speed: Why not both? (2021)
• Broken Encapsulation (2021)
• How to create small Docker images for Rust (2021)
• Rustacean Principles - Set of principles guiding Rust development and its open source organization. (Code)
• Rustacean Principles, Continued (2021)
• Explaining rust-analyzer - YouTube (2021)
• Rome will be written in Rust (2021) (HN) (Tweet)
• Richard Feldman’s Introduction to Rust workshop (Code)
• Example rust application to showcase error handling patterns
• Writing a storage engine in Rust: Writing a persistent BTree (Part 1) (2021)
• Optimize Rust binaries size with cargo and Semver (2021)
• GhostCell: Separating Permissions from Data in Rust (Code) (Reddit)
• Why Rust over C++ (2021)
• Rust for Rustaceans by Jon Gjengset (2021)
• Rustacean Station Podcast - Community project for creating podcast content for the Rust programming language. (Twitter)
• Finding Closure in Rust (2015)
• Common Newbie Mistakes and Bad Practices in Rust: Bad Habits (2021) (Reddit)
• Michael-F-Bryan's posts on Rust
• LSP-rust-analyzer - Convenience package for rust-analyzer.
• What makes Rust faster than C/C++? (2021)
• Rust for the Polyglot Programmer
• Rust Graphics Meetup
• Plugins in Rust: Diving into Dynamic Loading (2021)
• Fenix - Rust toolchains and rust analyzer nightly for nix.
• Crust of Rust: functions, closures, and their traits (2021)
• Rust and GCC, two different ways (2021)
• Designing an API Client in Rust: New Rspotify Version a Year Later (2021)
• Contributing to Rust std (2021)
• Making slow Rust code fast (2021)
• Phantom Types in Rust (2021)
• Password auth in Rust, from scratch - Attacks and best practices (2021)
• Error Handling In Rust - A Deep Dive (2021)
• Building Cloud-native applications with Rust - the good, the bad and the ugly - Luca Palmieri (2021)
• Rust Option 30x more efficient to return than Java Optional (2021) (HN) (Reddit)
• Rust Adventure - Learn to build reliable and efficient software in Rust. (Tweet) (GitHub)
• Structuring, testing and debugging procedural macro crates (2021)
• Builder pattern in Rust (2021) (HN) (Lobsters)
• What is Rust written in? (2021)
• WebApp.rs - Web application completely written in Rust.
• Rust 1.56.0 and Rust 2021 (HN)
• A Rust optimization story (2021) (HN)
• Debounce (2021)
• My ideal Rust workflow (2021) (HN)
• Former HFT C++ programmer, on how Rust fixes C++'s serious issues (2021) (Reddit)
• rftrace - Rust Function Tracer.
• Test-Driving the Rust Model Checker (RMC) (2021)
• khaki - Tool to write rust "scripts" with less boilerplate.
• What Memory Model Should the Rust Language Use? (2021) (Reddit) (HN) (Lobsters)
• View types for Rust (2021) (Reddit)
• Const Generics in Rust (2021) (HN)
• Causing problems with Rust traits (then fixing them) (2021) (Tweet)
• Working with signals in Rust - some things that signal handlers can't handle (2021)
• Collection of Rust Tips and Tricks
• Rust Iterator Items An exploration of syntax
• Async Cancellation (2021) (HN)
• Rust Is The Future of JavaScript Infrastructure (2021) (HN) (Tweet)
• The Rust compiler has gotten faster again (2021) (HN) (Reddit)
• What does &mut &[T] mean? (2021) (Lobsters)
• Rust data structures with circular references (2021) (HN)
• Testing multiple implementations of a trait in Rust (2021)
• SIMD explained using waffles
• How to find difference between sum and product types (2021)
• The Little Book of Rust Books - Catalogue of Rust mdbooks. (Code)
• Rust Edition Guide - Guide to changes between various editions of Rust. (Code)
• Beginner's Series to Rust
• The Little Book of Rust Macros (Code) (Old Version) (HN)
• What do you NOT like about Rust? (2021)
• Instrument a Rust Application with OpenTelemetry (2021)
• A Tale of Three Rust Codebases (2021)
• Will rust ever have a futures executor in std? (2021)
• A prioritised micro-batch scheduler in rust (2021)
• Endianness, API Design, and Polymorphism in Rust (2021) (HN)
• Rust Machine Learning Book (Code)
• The Rust Build System (2021)
• Portable and interoperable async Rust (2021) (Code)
• Higher Kinded Types in Rust (2021) (HN)
• Siderophile - Find the ideal fuzz targets in a Rust codebase.
• Rust Error Handling (2021) (Reddit)
• The Taxonomy of Pointers (2021)
• Move Constructors in Rust: Is it possible? (2021)
• Refactoring to Rust Book (2021) (Code)
• Bitmapper's Companion - zine/book about bitmap drawing algorithms and math with code examples in Rust
• How Not to Learn Rust (2021) (HN)
• A Beginner's Guide to Parsing in Rust (2021) (Lobsters)
• A brutally effective hash function in Rust (2021) (Lobsters)
• Accurate mental model for Rust's reference types
• Authoring a SIMD enhanced Wasm library with Rust (2021)
• A workaround for Rust's lack of structural subtyping (2021)
• rust-san - How-to: Sanitize your Rust code.
• rust-musl-builder - Docker container for easily building static Rust binaries.
• Writing embedded firmware using Rust (2021)
• Contexts and capabilities in Rust (2021)
• Using Type-Level Programming in Rust to Make Safer Hardware Abstractions (2019) (Code)
• Arc Borrowing Patterns (2021)
• My negative views on Rust (2021) (HN)
• Thoughts on Context and Capabilities in Rust (2021) (Reddit)
• Learn Rust Programming Course – Interactive Rust Language Tutorial on Replit (2021)
• Futuristic Rust: context emulation (2021) (Reddit)
• This Year in Embedded Rust: 2021 edition (HN)
• Ask HN: What are some good Rust code samples? (2021)
• Rust Ranges and suffering (2021)
• The Embedonomicon - How to bootstrap support for a no_std target. (Code)
• Why is my Rust build so slow? (2021) (HN)
• rust-analyzer in 2021
• Rustacean Station Podcast (Web Code)
• Profiling linkers (2022)
• In Defense of Async: Function Colors Are Rusty (2022) (HN)
• Three Kinds of Polymorphism in Rust (2022)
• Rust in 2022 (HN)
• borrow-checker-faqs (2021)
• How Bevy uses Rust traits for labeling (2022)
• Grids in Rust, part 1: nested vs. flat Vecs (2021)
• Async Rust in Practice: Performance, Pitfalls, Profiling (2022) (HN)
• Why I use a debugger (2022) (HN)
• Format Strings in Rust 1.58 (2022) (HN) (Reddit)
• Rustnote - My personal notes for Rust built with mdbook.
• Captures in closures and async blocks (2021)
• Rain's Rust CLI recommendations - Recommendations for how to organize and manage Rust CLI applications. (Code)
• Durability and Redo Logging (2022)
• Rust Futures and Tasks (2022) (Lobsters)
• On self-modifying executables in Rust (2022) (HN)
• Rust extension traits, greppability and IDEs (2022) (Lobsters) (HN)
• Uninitialized Memory: Unsafe Rust is Too Hard (2022) (Lobsters) (HN) (Reddit)
• A look back at asynchronous Rust (2021)
• Async Rust: Panics vs. Cancellation (2022) (HN)
• Triagebot - Triage and team assistance bot for the rust-lang organization.
• Type Exercise in Rust - Learn Rust black magics by implementing an expression framework in database systems.
• AdaCore and Ferrous Systems Joining Forces to Support Rust (2022) (HN)
• Go concurrency patterns in Rust
• Downcasting in Rust (2022) (Reddit)
• Diving Deep: implied bounds and variance (2022)
• Some mistakes Rust doesn't catch (2022) (Lobsters) (HN) (Reddit) (Tweet)
• if-else chains considered harmful (2022)
• Dare to ask for more #rust2024
• Rust on iOS and Mac Catalyst: A Simple, Updated Guide (2022)
• A Rust match made in hell (2022) (Reddit)
• What makes ripgrep so fast? (2022)
• Rust started as a personal project in 2006 (HN)
• What does it mean when people say that "Rust does not have a stable ABI"? (2022)
• Lineiform - Meta-JIT library for Rust interpreters. (Article)
• More Enum Types (2022)
• Ultimate Rust Crash Course (Code)
• What Is Rust's Hole Purpose? (2022) (HN)
• How to Learn Rust with Tim McNamara (2022)
• Notes On Module System (2021)
• Trait object based deserialization in Rust
• Kani Rust Verifier - Bit-precise model-checker for Rust.
• Rust Compiler Ambitions for 2022 (Reddit)
• From JavaScript to Rust Book (Reddit)
• Rust 1.59.0 with inline assembly support etc. (2022) (HN) (Reddit)
• Rust on Exercism (Code)
• IDEs and proc-macros (2022)
• A taste of Rust (2022) (Lobsters)
• Naive Bayes Classifier (2022)
• ddbug - Display debugging information.
• Rust's Rules are Made to be Broken (2022)
• Rust By Practice - Practice Rust with typical examples, challenging exercises and small practical projects. (Code)
• Implementing and Optimizing a Wordle Solver in Rust (2022) (Code) (Reddit)
• Request Coalescing in Async Rust (2022) (HN) (Reddit)
• Things I hate about Rust, redux (2022) (HN) (Reddit) (Lobsters)
• A zero-overhead linked list in Rust (2021)
• Implementing RAII guards in Rust (2021)
• Creating an Iterator in Rust (2021)
• An In-Depth Introduction To Idempotency (2022)
• Live-Coding Rust with Tim McNamara – Functional Futures (2022) (Transcript)
• OXUI - Cross platform native GUI in Rust.
• Rust ownership, the hard way
• Rust's Unsafe Pointer Types Need An Overhaul (2022) (Lobsters)
• You can't spell trust without Rust Thesis
• Using Rust to render things to canvas can often be slower than HTML
• High Assurance Rust: Developing Secure and Robust Software (Code)
• Terse Rust learning material - Notes I take during learning Rust from The Rust book and Rust by example.
• Self Modifying Code (2022)
• Practical course: Advanced Systems Programming in C/Rust
• Creating a new Clippy lint (Rust) (2022)
• Still Rusting - One Year Later (2020) (Lobsters)
• Strict provenance: a teachable memory model (experiment) for Rust
• What use cases does Rust cover better than Go? (2022)
• Anyone using rust in production? what do you do? (2022)
• Why Rust mutexes look like they do (2022) (Reddit) (Lobsters)
• Futures Nostalgia (2022) (Reddit)
• Arenas and Rust (2021)
• Do you prefer functional programming style when using rust? (2022)
• Understanding the Strategy Pattern (Lobsters)
• What is your favorite Rust specific feature that you miss in other languages? (2022)
• Myths and Legends about Integer Overflow in Rust (2016) (Lobsters)
• Rust. How do I start?
• Rust Lang Roadmap for 2024 (Reddit) (HN)
• Rust Secure Code Working Group
• Rust 1.60.0 (2022) (Reddit) (HN) (Lobsters)
• Instant::now() what? (2022)
• A Practical Analysis of Rust's Concurrency Story (2019)
• Hands-On Microservices with Rust Book (2019) (Code)
• What Is Rust's unsafe? (2019) (HN)
• Achievement unlocked: rustc segfault (HN)
• How to speed up the Rust compiler in April 2022 (Reddit)
• Rust Cheat Sheet
• ICE (Internal Compiler Error) - Small program to automatically find crashes in the rust compiler using rustcs own tests and different feature flags.
• Rewriting sysctl in Rust: systeroid (2022) (HN)
• Rust-101 - Tutorial for the Rust language. (Code)
• Different 'modes' of Rust you can program in
• From Python into Rust Guide - Quick reference guide for the Pythonista in the process of becoming a Rustacean.
• Benchmarking and analyzing Rust performance (2022)
• Rust from 0 to 80% for JavaScript Developers (2022) (HN)
• Rust Meetup Linz (Twitter)
• Async Rust: Portability and Interoperability - Nick Cameron (2022)
• An O(1) Generic Blog Post About Rust (2022) (HN)
• Single Page Applications using Rust (2020)
• Bugs that the Rust compiler catches for you (2022) (HN)
• Building Rust code for my OpenWrt Wi-Fi router (2022) (HN)
• RustBelt: Securing the Foundations of the Rust Programming Language (2018) (HN)
• Puzzling Strong Updates in Rust (2022)
• Rust from 0 to 80% for JavaScript Developers (2022) (HN)
• Comparing Rust supply chain safety tools (2022) (Lobsters)
• Rust grammar for tree-sitter
• Secure Rust Guidelines (Code) (HN)
• Safe representation of restricted values (2022)
• Dancing with the compiler: Rust and explicitness (2022)
• Safe operations with typestate in Rust (2021)
• Safe JSON representations with Rust (2021)
• Why can't Rust have have dynamic linking of dependencies? (2022) (Tweet)
• The Rust Borrow Checker – A Deep Dive (2022) (HN)
• Rust: A Critical Retrospective (2022) (HN) (Lobsters)
• Rust Ergonomics: Default and From (2022)
• Custom Allocators in Rust (2022)
• Typed Type Exercise in Rust - Build database expression type checker and vectorized runtime executor in type-safe Rust.
• What are legitimate problems with Rust? (2022)
• Crash reporting in Rust (2022) (Tweet)
• Fixing Memory Leaks in Rust (2022)
• MiniRust - Cornerstone of my vision for a normative specification of Rust semantics.
• Build your own JIRA with Rust
• Builder Lite (2022)
• TypeRust - Simple Rust playground where you can build or run your Rust code and share it with others. (Code)
• Rust Concurrency Cheat Sheet
• Rust Is Hard, Or: The Misery of Mainstream Programming (2022) (HN)
• Async Rust doesn't have to be hard (2022) (HN) (Reddit)
• Creating a minimal ELF-64 file with Rust
• Why Rust easily optimizes out smart pointers where C++ cannot? (2022)
• Arc and Mutex in Rust (2022)
• Algorithms implemented in Rust, explained
• Trivia About Rust Types (2022)
• Functional Programming in Rust (2022) (Reddit)
• Caches In Rust (2022)
• How to Rust articles
• Rust without the async (hard) part (2022) (Lobsters)
• Learn Rust Reddit
• Rust Async Cancellation: A Case Study (2022)
• Flavors of enums with Rust bindgen (2022) (HN)
• Everything Is Broken: Shipping Rust-Minidump at Mozilla (2022) (HN)
• Async I/O in Depth: Thread Pools, Radix Trees, Channels and More - High Performance HTTP Web Servers (2022)
• How to make Rust leak memory (also: how to make it stop) (2022) (Lobsters)
• Implementing strace in Rust (2022)
• ra-multiplex - Multiplex server for rust-analyzer, allows multiple LSP clients (editor windows) to share a single rust-analyzer instance per cargo workspace.
• Unsafe code highlighting with rust-analyzer (2022)
• Experimenting with Rust in Chromium (HN)
• lockbud - Statically detect deadlocks bugs for Rust.
• Passing small types by value vs by reference comparison
• Jon Gjengset | All Things Rust | Rust For Rustaceans (2022)
• Deadlock-free Mutexes and Directed Acyclic Graphs (2022) (Lobsters)
• Rust 1.62.0 (2022) (HN)
• Many modes: a GATs pattern (2022)
• Best book after the official Rust book? (2022)
• rfcbot - Manages asynchronous decision making on Rust issues and PRs.
• The last two years in Miri (2022)
• Data Engineering in Rust (2022) (Lobsters)
• A Pleasing Symmetry in Rust (Lobsters)
• Optimized enum sizes in Rust (2017) (HN)
• When Rustc Explodes (2022) (HN)
• How I went about learning Rust (2022) (HN)
• A performance retrospective using Rust (2022)
• Rust should not have provided unwrap (2022) (HN)
• Async Rust: What is a runtime? Here is how tokio works under the hood (2022) (HN)
• Elegant and performant recursion in Rust (2022) (Tweet)
• How to speed up the Rust compiler in July 2022
• Building a Rust Mentality (2022) (Lobsters)
• Ferrocene Language Specification - Document describing the Rust language. (Code) (HN)
• Why I moved from Rust to TypeScript (2022) (Lobsters)
• Rust Is Actually Portable (2022) (HN)
• Actually Portable Executables with Cosmopolitan Libc and Rust
• Fully generic recursion in Rust (2022) (Lobsters)
• Uncovering a Blocking Syscall (2022)
• Rust's Keyword Generics Initiative (Code) (Lobsters)
• Rust labs for Performance Ninja Class
• Taking ownership of memory in Rust (2022)
• Thoughts on static linking in Rust and how it affects distro maintainers (Lobsters)
• Formally Verifying Rust's Opaque Types (2022) (HN)
• Hot Reloading Rust — for Fun and Faster Feedback Cycles (2022) (HN)
• Rust Default Values for Maintainability (2022)
• Non-lexical lifetimes (NLL) fully stable (2022)
• So Zero It's ... Negative? (2022)
• Rust Analyzer User Manual
• MiniRust (2022) (HN)
• Using unwrap() in Rust is Okay (2022) (Lobsters)
• A performance retrospective using Rust (part 1) (2022)
• Rust 1.63 (2022) (HN) (Lobsters)
• Rust in Perspective (2022) (Reddit)
• Comparing Rust's and C++'s Concurrency Library (2022)
• Gotchas and warts in Rust Lang (Lobsters)
• WASM demo of rust-analyzer
• Rust – A hard decision pays off (2022) (HN)
• Crabs All the Way Down: Running Rust on Logic Gates (2022)
• Design Patterns in Rust
• What improvements would you like to see in Rust or what design choices do you wish were reconsidered? (2022) (Tweet)
• The Sheer Terror of PAM (2022)
• RustConf 2022 - ASYNC RUST: PAST, PRESENT, AND FUTURE GENERAL by Nick Cameron
• Glacier - Repository is used to test internal compiler errors (also known as ICEs) in Rust.
• Bryan Cantrill on Rust and the Future of Low-Latency Systems (2022)
• RustConf 2022 - YouTube
• Tachyon - Rust compiler backend focused on compilation speed.
• Lightly organized personal notes about Rust
• Attacking Firecracker: AWS' microVM Monitor Written in Rust (2022)
• Speeding up incremental Rust compilation with dylibs (2022)
• Creative Projects for Rust Programmers (2020) (Code)
• You Can't Do That: Abstracting over Ownership in Rust with Higher-Rank Type Bounds. Or Can You? (2022)
• The Newtype Pattern in Rust (2020)
• How to learn modern Rust (HN)
• Rust Workshop (2022)
• A personal list of Rust grievances (Lobsters) (Reddit)
• Rust stabilizes generic associated types (2022)
• Ten challenges for Rust (2022) (Lobsters) (HN)
• Create Rust binaries, and Docker images with Nix (2022)
• What I learned from building an emoji URL shortener in Rust (2022)
• Duolingo but for learning Rust
• What I meant by the "soul of Rust" (2022)
• Rust 2024 the Year of Everywhere? (2022) (Reddit) (HN)
• What's your favorite Rust design pattern? (2022)
• Crust of Rust: build scripts and foreign-function interfaces (FFI) (2022)
• Why are Rust programs slow to compile? (2022)
• RRust - Reversible subset of Rust inside of Rust.
• Why Async Rust (2022)
• Rust performance learnings