FerrousPath

Roadmap

47 lessons in five levels. Ticks show what you have marked complete in this browser.

0/47
Level 1 · Beginner10 lessons · ~3.7 h

Foundations

Install the toolchain, learn the syntax, and meet ownership — the idea everything else rests on.

By the end: You can write small programs and read compiler errors without panic.

  1. ✓1.1Getting startedWhat Rust is for, how to install it, and your first program built with Cargo.15 min
  2. ✓1.2Variables and typesBindings, mutability, shadowing, and the scalar and compound types every program is built from.20 min
  3. ✓1.3Functions and control flowExpressions versus statements, functions, if, loops, and why almost everything in Rust produces a value.20 min
  4. ✓1.4OwnershipThe three rules that let Rust free memory without a garbage collector — and why a moved value cannot be used again.25 min
  5. ✓1.5References and borrowingUsing a value without owning it — shared and mutable references, the aliasing rule, and slices.25 min
  6. ✓1.6Structs and methodsDefining your own data types, attaching behaviour with impl blocks, and deriving common traits.20 min
  7. ✓1.7Enums and pattern matchingTypes that are one of several shapes, Option instead of null, and match as an exhaustive case analysis.25 min
  8. ✓1.8Collections and stringsVec, String and HashMap — the three collections you will use daily — and why you cannot index a string.25 min
  9. ✓1.9Error handlingPanics for bugs, Result for failures you expect, and the question-mark operator that makes propagation painless.20 min
  10. ✓1.10Modules, crates and CargoOrganising code into modules, controlling visibility, using dependencies from crates.io — and a first project.25 min
Level 2 · Intermediate8 lessons · ~3.8 h

Practitioner

Generics, traits, lifetimes, iterators, smart pointers, and the habits of idiomatic Rust.

By the end: You can design a library API and ship a tested command-line tool.

  1. ✓2.1GenericsWriting code once for many types, how monomorphization makes it free at runtime, and const generics.20 min
  2. ✓2.2TraitsShared behaviour without inheritance — defining, implementing and deriving traits, and the standard traits every Rust programmer knows.30 min
  3. ✓2.3LifetimesHow the compiler reasons about how long references stay valid, what the annotations mean, and when you need to write them.30 min
  4. ✓2.4Closures and iteratorsAnonymous functions that capture their environment, the three Fn traits, and lazy iterator pipelines that compile down to tight loops.30 min
  5. ✓2.5Smart pointers and interior mutabilityBox, Rc, RefCell, Weak and Cow — heap allocation, shared ownership, and mutation behind a shared reference.30 min
  6. ✓2.6Error handling in depthDesigning error types, converting with From, error chains, and when to reach for thiserror and anyhow.20 min
  7. ✓2.7Testing and documentationUnit tests, integration tests, doc tests, property testing, and the tooling that keeps a codebase healthy.20 min
  8. ✓2.8Project: a command-line search toolPut Level 2 together — build a small grep with a library core, clean error handling, tests, and idiomatic API design.45 min
Level 3 · Advanced11 lessons · ~5.4 h

Systems

Threads, async, macros, unsafe, FFI, WebAssembly, embedded, and performance work.

By the end: You can build concurrent services and cross the boundary to C, the browser, and bare metal.

  1. ✓3.1Threads and shared stateFearless concurrency — spawning threads, Send and Sync, channels, Mutex, RwLock, and scoped threads.30 min
  2. ✓3.2Async and awaitFutures as state machines, executors, tasks, cancellation, and how to write concurrent I/O with Tokio.35 min
  3. ✓3.3Trait objects and dynamic dispatchdyn Trait, vtables and fat pointers, dyn compatibility, and choosing between static and dynamic dispatch.25 min
  4. ✓3.4Advanced traitsAssociated types versus generics, generic associated types, higher-ranked bounds, coherence, sealed traits and extension traits.30 min
  5. ✓3.5Declarative macrosmacro_rules! — pattern-matching on syntax, repetition, hygiene, and when a macro is the right tool.25 min
  6. ✓3.6Procedural macrosDerive, attribute and function-like macros — Rust programs that run inside the compiler and write Rust.30 min
  7. ✓3.7Unsafe RustWhat unsafe actually unlocks, what undefined behaviour is, raw pointers, and how to wrap unsafety in a sound safe API.35 min
  8. ✓3.8FFI — talking to CCalling C from Rust and Rust from C, repr(C), strings and ownership across the boundary, bindgen and cbindgen.30 min
  9. ✓3.9Performance engineeringMeasure first — benchmarking, profiling, allocation, data layout, bounds checks, inlining, SIMD, and build configuration.30 min
  10. ✓3.10WebAssemblyCompiling Rust for the browser and beyond — linear memory, the raw ABI used by this site's lab, wasm-bindgen, and WASI.30 min
  11. ✓3.11no_std and embedded RustRust without an operating system — core and alloc, panic handlers, memory-mapped registers, HALs, and async on microcontrollers.25 min
Level 4 · Expert9 lessons · ~5.7 h

Expert

Layout, variance, drop check, Pin, atomics, lock-free structures, and executors from scratch.

By the end: You can write and audit unsafe abstractions that are sound for every safe caller.

  1. ✓4.1Memory layout and representationSize, alignment and padding, niches, fat pointers, dynamically sized and zero-sized types, uninitialised memory, and the repr attributes.35 min
  2. ✓4.2Subtyping and varianceLifetimes as a subtype relation, covariance, contravariance and invariance, and why &mut T must be invariant.30 min
  3. ✓4.3Drop, drop check and PhantomDataDestructor order, panic safety and leak safety, why a generic Drop makes the borrow checker stricter, and how PhantomData expresses ownership.30 min
  4. ✓4.4Pin and self-referential typesWhy moving breaks self-references, what Pin guarantees, Unpin, structural pinning, and how async state machines depend on all of it.35 min
  5. ✓4.5Atomics and memory orderingThe memory model behind Relaxed, Acquire, Release, AcqRel and SeqCst — happens-before, compare-and-swap, and how to choose an ordering.40 min
  6. ✓4.6Lock-free data structuresProgress guarantees, the Treiber stack, the ABA problem, memory reclamation with epochs and hazard pointers, and linearizability.40 min
  7. ✓4.7Async internals: build an executorThe Future contract, wakers and RawWaker, a leaf future backed by a timer thread, and a complete multi-task executor in a hundred lines.45 min
  8. ✓4.8Type-level programmingTypestate, phantom types, const generics, type-level computation with traits, and making invalid programs fail to compile.35 min
  9. ✓4.9Capstone: implementing VecBuild a growable array from raw allocation — NonNull, Layout, growth, zero-sized types, Drop, Deref, IntoIter — and audit it for soundness.50 min
Level 5 · Doctorate9 lessons · ~6.8 h

Research

Type theory, borrow-checker formalisms, aliasing models, RustBelt, verification, and open problems.

By the end: You can read the papers, question the semantics, and contribute to the language itself.

  1. ✓5.1The type theory of ownershipSubstructural logics, affine types, regions, and the intellectual lineage of Rust — from linear logic and Cyclone to formal calculi such as Oxide.45 min
  2. ✓5.2Inside the borrow checker: NLL and PoloniusMIR, liveness and region inference in non-lexical lifetimes, two-phase borrows, and the loan-based reformulation known as Polonius.45 min
  3. ✓5.3Aliasing models: Stacked Borrows, Tree Borrows and provenanceWhat unsafe code is actually allowed to do — operational semantics for references, pointer provenance, and the optimisations these models exist to justify.50 min
  4. ✓5.4Trait solving and coherenceTraits as logic programming — Horn clauses, proof search, coinduction, normalisation, the next-generation solver, and the known soundness holes.45 min
  5. ✓5.5Compiler architectureFrom source text to machine code — the representations, the query system and incremental compilation, monomorphization, backends, and how to start contributing.40 min
  6. ✓5.6RustBelt: proving unsafe code soundSemantic type soundness, separation logic and Iris, the lifetime logic, and how the standard library's unsafe abstractions were machine-verified.50 min
  7. ✓5.7Formal verification of Rust programsFrom Miri and model checking to deductive verifiers — Kani, Creusot, Prusti, Verus, Aeneas, Flux — and why ownership makes Rust unusually verifiable.45 min
  8. ✓5.8Weak memory and concurrency theoryFormal memory models — sequential consistency, TSO, the C++/Rust model, litmus tests, out-of-thin-air, linearizability, and model checking with loom.45 min
  9. ✓5.9The frontier: open problems and how to contributeWhat is unsolved in Rust's design, semantics and tooling; how the language evolves; a doctoral reading list; and how to start doing research.40 min