Rust ​

Learn Rust 101, Rust Book (interactive version), Comprehensive Rust Guide & rustlings are best intros into Rust. Together with rust cheat sheet.

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

I use Rust to build desktop apps with Tauri. But try to use it for more things. I also like Go & TS for scripting / browser code.

David Tolnay writes nice Rust code.

Xilem: an architecture for UI in Rust is nice read for making UI in Rust.

Enjoyed Building Web UI's in Rust w/ Greg Johnston episode on writing Rust code for Web UIs.

Rust Atomics and Locks: Low-Level Concurrency in Practice is great book.

MacroKata is great for learning macros. Idiomatic Rust & Rust Performance are nice reads to learn best practices. LifetimeKata is nice to understand lifetimes.

Fenix is interesting. Aquascope is nice tool.

Rerun has great code to study for how to build an app in Rust.

Railway CLI is great.

Building a Rust service with Nix is great series. muslrust is nice for compiling Rust to run in cloud settings.

My main blocker with not using Rust more is compilation times. But there are ways to improve this.

Templates ​

• Rust Service Template

OSS Rust websites ​

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

Code ​

cargo watch -q -x "run -q" # watch for Rust files and run on changes

Notes ​

• For rust to be fast your dependency hierarchy must be very flat. The more dependent your modules are, the slower incremental builds will be.
• 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.
• unsafe permits calling other unsafe code, dereferencing raw pointers, reinterpreting unions, and implementing unsafe traits like Send and Sync. It does not “turn off” the type system, borrow checker, or anything else
• The value of Rust is not just that it prevents data races, but the way it prevents data races: by having marker traits which indicate whether a type is thread-safe. This works well, because the marker traits follow the ownership tree. If you own something that is not thread-safe, then you are yourself (by default) not thread safe. This ability to still work with a type that is not thread-safe is what's interesting: if you have ownership of it, then it's still safe to access it, because you know nobody else is accessing it. In a GC'd language, a non-thread-safe type would have no supported operations, because you could never be sure if you were the only one accessing it.

Links ​

• Rust language book (Code) (Exercises code)
• Rust by Example
• Rust Language Reference (Code)
• Rust Code
• Idiomatic Rust - Peer-reviewed collection of articles/talks/repos which teach concise, 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) (HN)
• Minimizing Rust Binary Size
• Rust Programming Tipz
• Rustlings - Small exercises to get you used to reading and writing Rust code. (Solutions) (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) (HN)
• 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 Grouped by Level (HN)
• 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. (HN)
• 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) (Makepad: Designing modern UIs with Rust - Rik Arends)
• 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 (2022) (Reddit) (Code) (Reddit)
• 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) (Web)
• 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) (HN)
• 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. (HN)
• 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
• “Rust is safe” is not some kind of absolute guarantee of code safety (2022) (HN) (Reddit)
• No Boilerplate - YouTube - Fast technical videos. (Code)
• Unsafe Rust is not C (2022) (Lobsters)
• Rust's Result Type is Cool (2022) (Lobsters)
• Hard Mode Rust (2022) (Reddit) (Lobsters)
• You can't "turn off the borrow checker" in Rust (2018)
• EuroRust (Twitter)
• Rust Atomics and Locks: Low-Level Concurrency in Practice (2022) (Code) (HN)
• Building a modern web app with Rust, Bazel, Yew and Axum (2022)
• Concurrency programming via Rust Book
• Why Rust? (2022) (HN) (Reddit)
• Rust vs Go (2022)
• How to speed up the Rust compiler in October 2022
• Do we need a "Rust Standard"? (2022) (HN) (Lobsters)
• Rust Before Main - Ryan Levick (2022)
• Adventures In Cross Compilation (2022) (Lobsters)
• Const Syntax (2022)
• Speeding up the Rust compiler without changing its code (2022) (HN)
• Boxes, Heaps, and Stacks - Tim McNamara - Rust Linz (2022)
• MacroKata - Set of exercises which you can use to learn how to write macros in Rust. (Code)
• Ownership as explained in the Rust book
• Rust Debugging Extensions
• Rust language book interactive
• Rust 1.65.0 (2022) (HN) (Lobsters)
• New diagram-based explanation of Rust/C++20 atomic orderings
• Scoped threads in Rust, and why its async counterpart would be unsound (2022)
• 2 years of fiddling with Rust (2022) (HN)
• Explain the GATs like I was 5 (2022) (HN)
• promote-release - Tool used by the Rust project to publish new releases of the Rust toolchain.
• Creating a priority queue with a custom sort order using a binary heap in Rust (2022)
• Guide to Error Handling in Rust (HN)
• Property-Based Testing in Rust with Arbitrary (2021) (HN)
• Debugging a Core Dump with MDB (2022)
• Stop writing Rust linked list libraries (2022)
• Carefully exploring Rust as a Python developer (2022) (HN)
• Tell HN: Rust Is Complex (2022)
• Introduction to Rust Programming Language (2022)
• Is Rust Stack-Efficient Yet? (HN)
• What are Rust’s biggest weaknesses? (2022)
• Stable MIR Librarification Project Group
• Patterns for not fighting Rust burrow checker
• If a Tree Falls in a Forest, Does It Overflow the Stack? (2022)
• How to read complicated Rust types
• Slice patterns in Rust (2022)
• Using Rust at a startup: A cautionary tale (2022) (HN) (Reddit) (Reddit)
• A Better Way to Borrow in Rust: Stack Tokens (2022) (Reddit) (Code)
• Safely writing code that isn't thread-safe (2022) (HN)
• Threads and messages with Rust and WebAssembly (2022)
• Rust Docker Cheatsheet - Notes on building and running Rust binaries in Docker.
• Rust to assembly: Arrays, Tuples, Box, and Option handling (2022)
• Rusty ownership and the lifecycle’s stone (2022) (HN)
• How much does Rust's bounds checking actually cost? (2022) (Lobsters) (HN) (Reddit)
• Learning Rust with ChatGPT, Copilot and Advent of Code (2022) (HN)
• Rust for JS devs : Borrow Checker (2022)
• Data-driven performance optimization with Rust and Miri (2022) (HN)
• How I got involved in the Rust community (2022) (HN)
• A Look at dyn* Code Generation (2022)
• A neat XOR trick (2022) (HN)
• When types lie - a rust themed whodunnit (2022)
• Cranelift Progress in 2022 (Reddit) (Lobsters)
• Rust 1.66.0 (2022)
• Gene Michaels - Alternative Rust code formatter. (Reddit)
• Sorting with SIMD (2022) (HN)
• Rust Magazine - Publication for the Rust programming language community. (Code) (Reddit)
• High Performance Rust UI (2022)
• Comprehensive Rust Guide from Google (HN) (Reddit) (Code) (HN)
• Implementing Rayon's Parallel Iterators - A Tutorial (2022)
• AWS re:Invent 2022 - Rust is interesting, but does it really make sense for me?
• Experimental Rust Feature: Safer Interoperable ABI (HN)
• Rust Async History, Libs, and Patterns (Katharina Fey) (2022)
• Cerberus - Python tool to unstrip Rust binaries on Linux.
• Mini Docker Rust
• Should Small Rust Structs be Passed by-copy or by-borrow? (2019) (HN) (Reddit) (Lobsters)
• Rust for Professionals (HN)
• A confusing lifetime error related to Rust's lifetime elision (2023)
• Zero-dependency random number generation in Rust (2023) (Lobsters)
• Generics in Rust (2023)
• Rust Formal Methods Interest Group (Code)
• Samsara, a safe Rust concurrent cycle collector (2023) (Reddit)
• Difference between Rust intristics and Rust lang items (with Haskell examples)
• Go devs that learned Rust, what are your thoughts on it? (2023)
• Does rust have a garbage collector? (2023)
• Scriptisto - Tool to enable writing one file scripts in languages that require compilation, dependencies fetching or preprocessing.
• GCC Front-End For Rust (2022) (Lobsters)
• Rust 101 course
• Finding Nice MD5s Using Rust (2022) (HN)
• The Hidden Control Flow — Some Insights on an Async Cancellation Problem in Rust (2023)
• Rust Unpopular Opinion (2023)
• Rust Nation 23
• From Python to Rust course
• RFC: Start working on a Rust specification
• Why is Rust's build system uniquely hard to use? (2023)
• Rust Concepts I Wish I Learned Earlier (2023) (Reddit)
• Rust in 2023: Growing Up (HN)
• Marker - Stable linting interface for Rust.
• Some Rust breaking changes don't require a major version (2023)
• Too many words about Rust's function syntax (2023)
• Next Rust Compiler (2023) (Reddit)
• Rust's Ugly Syntax (2023) (HN) (Reddit) (Lobsters)
• Capability-Safety I: Prelude (2023)
• My Vision for Creating Cross-platform Applications with Rust (2022)
• Async trait send bounds (2023)
• Learn unsafe Rust
• Improving Rust compile times to enable adoption of memory safety (2023) (Reddit) (HN)
• Rust Infrastructure automation
• Choosing where to deploy a Rust application (2023)
• Choosing a Rust Web Framework (2023)
• What's the difference between references and pointers in Rust? (2023) (Lobsters)
• Speeding up Rust semver-checking by over 2000x (2023) (Lobsters)
• Improving incremental test times in Rust (2023) (Lobsters)
• Introducing AdaCore, a Rust Foundation Silver Member (2023)
• Building a Cloud Database from Scratch: Why We Moved from C++ to Rust (2022) (HN)
• Reimplementing the Coreutils in a modern language (Rust) (HN)
• There and Back Again: Our Rust Adoption Journey (2022)
• When Rust hurts (2023) (Lobsters) (HN)
• Why is building a UI in Rust so hard? (2023) (Lobsters) (Reddit)
• LifetimeKata - Set of exercises to improve your understanding of lifetimes in Rust. (Code)
• Smoke-testing Rust HTTP clients (2020)
• Aquascope - Interactive visualizations of Rust at compile-time and run-time.
• I love building a startup in Rust. I wouldn't pick it again. (2023) (HN) (Reddit)
• Learn Rust with Rustlings 5.2.1 (No C required) (2022)
• Rust – What made it “click” for me (Ownership and memory internals) (2021) (HN)
• The Bull Case for Rust on the Web (2023)
• Writing Rust Best Practices (2023)
• Learn Rust With JetBrains IDEs (2023)
• Why does this Rust program leak memory? (2023)
• Keyword Generics Progress Report: February 2023 (Reddit)
• Statefulness in GUIs (2023)
• Faking Algebraic Effects and Handlers With Traits: A Rust Design Pattern (2022)
• Pretty Rust backtraces in raw terminal mode (2023)
• async let - A new concurrency primitve? (2022)
• ubrustc - Unborrowed Rust Compiler (rustc without a borrowchecker).
• Rust Coreutils: Fixing Low-Hanging Performance Fruit (2022)
• Ergonomic APIs for hard problems - Raph Levien (2022)
• Actors with Tokio – a lesson in ownership - Alice Ryhl (2022)
• Rust Web Development (2023)
• Speeding up Rust Code (2023)
• Releasing Rust applications with cargo dist (2023)
• Let's make an htop-like in your browser (with Rust) (2023) (Code)
• rustc-tools - Some internal rustc tools made accessible.
• Dealing with Cyclic Data in Rust (2022)
• Living with Rust Long-Term - Jon Gjengset (2023)
• Safety and Soundness in Rust (2023) (HN)
• Learn Rust with Gitoxide - YouTube
• The Registers of Rust (2023) (HN) (Lobsters)
• Leveraging Rust and the GPU to render user interfaces at 120 FPS (2023) (HN) (Tweet)
• Getting Past “Ampersand-Driven Development” in Rust - A mental model for ownership and borrowing (2023) (Lobsters)
• Bridging Async and Sync Rust Code - A lesson learned while working with Tokio (2023)
• Rewriting the CLI in Rust: Was It Worth It? (2023) (HN)
• Hands-On Functional Programming in Rust Book (2018) (Code)
• What learning resource has had the greatest impact in elevating your understanding and knowledge of Rust? (2023) (Tweet)
• Moving beyond Arc Mutex T - Katharina Fey (2023)
• Emitting Safer Rust with C2Rust (2023) (HN)
• Temporary lifetimes (2023)
• Patterns & Abstractions (2023)
• Why is building a UI in Rust so hard? (2023) (HN)
• Bringing Rust to the Xen Project (2023)
• Help me love Rust - compilation time (2023)
• Compile Times - The Rust Performance Book
• Why use Rust on the back end? (2023) (HN)
• Scaling Rust builds with Bazel (2023) (HN)
• Must move types [Linear types proposed for Rust] (2023)
• How to speed up the Rust compiler in March 2023
• How to Learn Rust (2023)
• Rust's Golden Rule (2023) (HN) (Reddit)
• Tree Borrows: A new aliasing model for Rust (2023)
• Rust Is a Scalable Language (2023)
• Linear Types One-Pager (2023)
• Rust: Not Just Zoom Zoom Fast (2023)
• Coq of Rust - Formal verification for Rust by translation to Coq.
• Rust's Poor Composability (2023) (HN)
• Custom allocators in Rust (2023)
• Spotting and avoiding heap fragmentation in Rust applications (2023) (HN)
• Learn Rust 101 (HN)
• Rust, RR, Neovim: A perfect debug combination (HN)
• Restructuring Patterns (HN)
• Understanding tracing's macros by rebuilding them from scratch (2023)
• Optional If Expressions (2023)
• What are some stuff that Rust isn't good at? (2023)
• Hypervisor Development in Rust (2023) (HN)
• What backwards-incompatible changes would you make in a hypothetical Rust 2.0? (2023)
• Building a GStreamer plugin in Rust with meson instead of cargo (2023)
• DOOM maps to SVG to laser cutter (2023)
• Data Oriented Parallel Value Interner (2023) (Lobsters)
• How Pydantic V2 leverages Rust's Superpowers (2023) (HN)
• makerust - Rust, but in a Makefile.
• Rust allows redeclaring local variables to great benefit (2023) (Lobsters)
• GCC 13 and the State of Gccrs (2023) (HN)
• How does async Rust work (2023) (HN)
• Bringing runtime checks to compile time in Rust (2023)
• What Is Type-Level Programming? (2023) (HN)
• Stabilizing async fn in traits in 2023 (Reddit)
• Building x86 Rust containers from Mac Silicon (2023)
• Pursuit of Performance on Building a JavaScript Compiler (2023)
• Entering the Garden of Ferris (2023)
• Iterator, Generator (2023) (Reddit)
• Rust 101 Crash Course (2022)
• Dioxus + TailwindCSS - Template for the Rust Web/Desktop framework Dioxus + TailwindCSS.
• A guide to test parametrization in Rust (2023) (HN)
• Giving, lending, and async closures (2023)
• Build a web server with Rust and Tokio (2023)
• How Much Memory Do You Need to Run 1 Million Concurrent Tasks? (2023)
• FunctionalRust - Examples of functional programing in Rust.
• What If We Pretended That a Task = Thread? (2023)
• How to Learn Rust (2023)
• A guide to closures in Rust (2023) (HN)
• Local Async Executors and Why They Should be the Default (2022)
• Getting meaningful stack traces from Rust tests returning a Result (2023)
• Flux -- Liquid Types for Rust (2023)
• Rust - Rosetta Code
• Rust to Assembly: Understanding the Inner Workings of Rust
• From Stacks to Trees: A new aliasing model for Rust (2023) (Reddit) (HN)
• Rust development environment setup
• The Rust I Wanted Had No Future (2023) (HN) (Lobsters)
• Rust Binary Analysis, Feature by Feature (2023)
• Rust criticism from a Rustacean (2023) (HN)
• Rust for "modern" C++ devs (2022)
• Quick-and-dirty attempt to get scoped tasks in Rust
• PWRS app - Progressive web rust application. (Code)
• Unsafe Rust and Miri by Ralf Jung (2023)
• Building vector search in 200 lines of Rust (2023)
• Iterating on Testing in Rust (2023) (HN)
• How we built the Grafbase local development experience in Rust (2023)
• Practical Procedural Macros in Rust (2022) (HN)
• How to think about async/await in Rust (2023)
• Rust Doesn't Have Named Arguments. So What? (2023) (Lobsters)
• Delimited Continuations, Demystified by Alexis King (2023)
• Mistakes with Rust smart pointers: when Deref goes wrong (2023) (HN)
• Back-end parallelism in the Rust compiler (2023)
• Maximizing Your Rust Code's Performance (2023) (Reddit)
• Rust 1.71.0 (2023) (HN)
• RustSmith: Random Differential Compiler Testing for Rust
• Unit-testing a web service in Rust (2023)
• RRUST: A reversible embedded language (2023)
• Generating terminal user interfaces with Ratatui + ChatGPT (2023)
• A visual tree iterator in Rust (2023)
• What I Learned Building a CLI App in Rust (2023)
• Make invalid states unrepresentable (2023) (Reddit)
• Mutex without lock, Queue without push: cancel safety in lilos (2023)
• More than you've ever wanted to know about errors in Rust (2022)
• How Turborepo is porting from Go to Rust (2023) (HN)
• Invention in Rust (2023)
• rustycli - Access the rust playground right in your terminal.
• Rust Functions Are Weird (But Be Glad) (2023)
• Rust Tutorial - YouTube
• Rust LLVM time analysis (2023)
• Crust of Rust: async/await (2021)
• Awesome Alternatives in Rust
• Procedural Macros in Rust
• Rust error handling with anyhow (2023)
• A Lock-Free Vector (2023)
• Visualizing memory layout of Rust's data types
• A failed experiment with Rust static dispatch (2023)
• Name before type: why 'age int' is better than 'int age' (2023)
• I need some WD-40 (2023)
• Mixing Python Notebooks + Rust (2023)
• Error handling Isn't All About Errors by Jane Lusby (2020)
• Let's Build a Cargo Compatible Build Tool (2023)
• Making illegal states unrepresentable (Lobsters)
• Data With Rust - Practical handbook for data engineering tasks in Rust.
• Rust Server Components (2023) (Lobsters)
• Inspecting rustc LLVM optimization remarks using cargo-remark (2023)
• Writing a basic code formatter in Rust (2023)
• Rust RFC Book
• Tokio bug that is not a bug, or: why I think AsyncRead is not well-designed (2023)
• Porting Boolrule To Rust (2023)
• How I make HashSets with zero boilerplate (2023)
• Rust 1.72.0 (2023) (HN)
• How to speed up the Rust compiler (2023) (HN)
• Exploring the Rust compiler benchmark suite (2023)
• Red Pen - Rust code linter.
• Patterns with Rust types (2022) (Lobsters)
• Async Rust Is A Bad Language (2023) (HN) (Reddit)