The problem: Rust has no shortage of tutorials, but no clear path
If you've tried to learn Rust, you know the pattern. You read The Rust Programming Language, get comfortable with ownership and borrowing, then hit a wall. What comes next? Tokio? Trait objects? Macros? Unsafe? Every source assumes you already know the prerequisite and skips the bridge. The result is a language that feels documented but unnavigable.
Rust is a systems programming language built for memory safety without a garbage collector, fearless concurrency, and zero-cost abstractions. It's used in operating system kernels, embedded firmware, network services, WebAssembly, and performance-critical infrastructure. But its learning curve isn't just steep — it's uneven. Some concepts click immediately; others, like lifetimes and variance, take months to internalize.
This roadmap breaks that curve into 131 focused chapters, each one a single concept with a real, working example.
What the roadmap covers
The series starts where every Rust journey does: what systems programming actually means, installing Rustup and Cargo, and understanding why immutability is the default. From there it moves through the language in deliberate layers.
Chapters 1–10 establish the foundation: types, functions, statements versus expressions, and control flow. These are short by design — the goal is momentum, not depth.
Chapters 11–18 tackle the concept that defines Rust: ownership. Stack versus heap, move semantics, the Copy and Clone traits, references, and the aliasing XOR mutability rule. If you've bounced off Rust before, it was probably here. This section makes the rules concrete.
Chapters 19–31 cover structs, enums, Option<T>, pattern matching, modules, and the standard collections. This is where Rust starts to feel like a usable language rather than a set of constraints.
Chapters 32–45 handle errors and abstractions: Result<T, E>, the ? operator, thiserror and anyhow, generics, traits, and lifetimes. Lifetimes get four dedicated chapters — elision rules included — because they're the single most misunderstood feature in the language.
Chapters 46–63 move into testing, closures, iterators, smart pointers, and concurrency. Box, Rc, RefCell, Arc, Mutex, and channels all get their own chapter.
Chapters 64–79 are advanced territory: trait objects, object safety, the orphan rule, operator overloading, declarative and procedural macros, and serde.
Chapters 80–89 cover async Rust from first principles — the Future trait, async/await, runtime architecture, streams — through to real applications: axum and actix-web for REST APIs, sqlx for databases, ratatui for terminals, egui and iced for GUIs, and Tauri for desktop apps.
Chapters 90–105 are unsafe Rust and low-level systems work: raw pointers, FFI, inline assembly, Pin, atomics, memory ordering, WebAssembly, no_std embedded development, and custom allocators.
Chapters 106–130 go deep: compiler internals (AST to HIR to MIR), monomorphization, variance and subtyping, async executor internals, zero-copy parsing, eBPF, kernel development, SIMD, fuzzing, and formal verification with Kani.
Chapter 131 is a cheatsheet.
Why this structure matters
Most Rust resources fall into two camps: beginner books that stop at generics, and reference material that assumes you already understand the compiler's mental model. This roadmap fills the gap between them. Each chapter is a single idea, written to be read in one sitting and tied to official documentation and current stable versions — not invented examples or imaginary features.
The progression is honest about difficulty. Chapters 1–30 are approachable for any programmer. Chapters 42–45 on lifetimes require patience. Chapters 90 onward assume you're comfortable with the language and want to understand what happens beneath it. That's not padding — it's the actual shape of mastering Rust.
Who this is for
- Developers coming from GC languages (Python, JavaScript, Go, Java) who want to understand ownership without hand-waving.
- C and C++ programmers curious about memory safety and what Rust's borrow checker actually prevents.
- Intermediate Rust users who can write working code but want to understand the compiler's internals.
- Systems engineers targeting embedded, kernel, eBPF, or WebAssembly work.
- Anyone who has read the Book and wondered what comes next.
The full series is available at tuts.kandz.me/category/programming/languages/rust.
131 chapters. One language. Start at chapter one and don't skip the ownership section.
Top comments (0)