A language built on a single bet: that “manual memory management or a garbage collector” was a false choice. Rust gets memory safety at compile time, with no GC and no runtime cost, by making ownership part of the type system.
~22,000 words across 18 notes. Built August 2026, cross-referenced against roadmap.sh Rust.
Source: [reference]. No Rust project in this vault yet, and nothing here has been argued with under real constraints. The first Rust build belongs in Project Ideas before these notes claim to be knowledge — reading is not a rank.
The thing worth understanding above everything else: ownership was designed to manage memory, and it turned out to eliminate data races for free. The borrow rule — one mutable reference or many immutable ones — makes a data race unrepresentable. Java and Go are memory-safe and will still let two threads corrupt a field. That accident is the most interesting result in the language’s design, and it’s why note 13 is called what it is.
Reading order
Notes 3, 4 and 5 are the hard part and everything after assumes them. Don’t skip ahead; do expect them to take longer than the rest combined.
Getting oriented
- Why Rust, and the Toolchain — [Beginner] — the problem no mainstream language had solved, what it costs,
cargo, and the compiler as a teaching tool - Language Fundamentals — [Beginner] — bindings, immutability by default, shadowing, expressions-as-values, and the two string types
The hard part — read slowly
- Ownership — [Beginner → Intermediate] — three rules, move semantics,
Copy, andDrop. The foundation for all of it - Borrowing and References — [Beginner → Intermediate] — the one rule, non-lexical lifetimes, slices, and the four patterns that get you unstuck
- Lifetimes — [Intermediate] — the scariest syntax, which only describes relationships rather than changing them. Elision means you rarely write them
Modelling data
- Structs, Enums and Pattern Matching — [Beginner → Intermediate] — sum types, exhaustive
match, and making invalid states unrepresentable - Option and Result — [Beginner → Intermediate] — no null, no exceptions, and the
?operator - Error Handling in Practice — [Intermediate] —
thiserrorfor libraries,anyhowfor applications, and errors as HTTP responses
Abstraction
- Traits — [Intermediate] — shared behaviour without inheritance, the orphan rule, static vs dynamic dispatch
- Generics and Trait Bounds — [Intermediate] — monomorphisation, closure traits, const generics
- Collections and Iterators — [Intermediate] — the best-designed trait in the library, and why chains are as fast as loops
When the compiler can’t prove it
- Smart Pointers and Interior Mutability — [Intermediate → Advanced] —
Box,Rc,RefCell,Weak, and moving the borrow check to runtime
Concurrency
- Concurrency — [Intermediate → Advanced] —
Send/Sync,Arc<Mutex<T>>, channels,rayon, and what “fearless” does and doesn’t mean - Async and Tokio — [Advanced] — futures, why the runtime isn’t in the language, and the three mistakes that make async slower than blocking
The deep end
- Unsafe and FFI — [Advanced] — the five things
unsafeactually permits, safe abstractions, and calling C - Modules, Cargo and Testing — [Intermediate] — visibility, workspaces, feature flags, and testing that’s mostly built in
- Macros — [Advanced] —
macro_rules!, derive macros, hygiene, and when a function would do - Performance and Zero-Cost Abstractions — [Advanced] — what’s genuinely free, what isn’t, and measuring instead of guessing
Where the frameworks are
Per the vault rule — languages/ teaches the language, backend/frameworks/ teaches the frameworks:
→ backend/frameworks/rust/ — Axum, Actix Web, tower
Rust vs Go, since both now live here
They’re often presented as competitors and mostly aren’t.
| Go | Rust | |
|---|---|---|
| Memory safety | GC | compile-time ownership |
| Learning curve | days | weeks to months |
| Compile speed | very fast | slow |
| Concurrency | goroutines, blocking style, no colouring | async/await + threads, colouring |
| Errors | if err != nil | Result + ? |
| Best for | services, infra tooling, team throughput | systems, latency-critical, embedded |
Go optimises for the team; Rust optimises for the machine and the compiler’s ability to prove things. Pick Go when the deadline and the headcount matter more than the last 10%. Pick Rust when a pause, a crash, or a memory bug is genuinely unacceptable.
Known gaps
- No project. The largest gap, and the one that matters
- Embedded /
no_std— a major Rust use case, entirely absent. Would connect to hardware/ - WebAssembly — one of Rust’s strongest niches, not covered
- Advanced type-level programming — GATs, HRTBs beyond a mention, typestate patterns
serdein depth — the most-used crate in the ecosystem gets only passing coverage
Related
- Rust Backends — Axum and Actix
- Languages — the language/framework split rule
- Go · Java — the other language courses
- Build Plan — what’s queued next
- Project Ideas — where the first Rust build should be logged
Software engineering
Infrastructure & security
Computer science
Hardware & engineering