Skip to content

Rust Mastery Blueprint — A 24-Week Master-Level Syllabus

Authoring lens: Senior Principal Systems Engineer / Rust Architect. Target outcome: A graduate of this curriculum should be capable of (a) submitting non-trivial PRs against rust-lang/rust, (b) owning a low-latency fintech matching engine or risk pipeline, or (c) writing a kernel module in rust-for-linux without supervision.

This is not a "learn Rust in N days" track. It assumes the reader is already a working software engineer who can read C, has shipped production code in some language, and is willing to read source code (LLVM, Tokio, glibc, the Rust reference) as a primary learning surface.

What you'll learn

A 24-week curriculum organized into six monthly modules, plus three reference appendices and a capstone catalog at the end.

Module What it covers
Prelude - Philosophy and reading list Why Rust; the affine type system; the cost model; reading list.
Month 1 - Foundations (Weeks 1–4) Toolchain, memory layout, ownership, error model.
Month 2 - Type System (Weeks 5–8) Lifetimes, variance, traits, smart pointers, Drop checker.
Month 3 - Concurrency and Async (Weeks 9–12) Atomics, lock-free, Pin/Unpin, Tokio & Smol internals.
Month 4 - Unsafe, FFI, Macros (Weeks 13–16) unsafe, FFI, declarative & procedural macros.
Month 5 - Production Architecture (Weeks 17–20) Hexagonal, zero-copy I/O, observability, testing.
Month 6 - Mastery and Capstone (Weeks 21–24) Custom data structures, no_std, rustc internals, capstone.
Appendix - Production Hardening LTO, PGO, BOLT, cargo-geiger, supply chain auditing.
Appendix - Data Structures Build-from-scratch reference: B-Tree, lock-free hash map, MPSC, slab.
Appendix - Contributing to rustc The compiler pipeline; bootstrap; MIR; first PR playbook.
Capstone tracks Three terminal projects, one per career track.

How Each Week Is Structured

Every weekly module follows the same five-section format so the reader can budget time:

  1. Conceptual Core-the why, with a mental model.
  2. Mechanical Detail-the how, down to layout and ABI where relevant.
  3. Lab-a hands-on exercise that cannot be completed without internalizing the concept.
  4. Idiomatic & Clippy Drill-read 2–3 lints, refactor a sample to silence them, understand why each lint exists.
  5. Production Hardening Slice-an LTO/PGO/cross-compile/audit micro-task that compounds across weeks.

Each week is sized for ~12–16 focused hours. Skip the labs at your peril; the labs are the curriculum.

Progression Strategy

The phases form a dependency DAG, not a linear track:

Foundations ──► Type System ──► Concurrency ──► Unsafe / FFI / Macros
       │              │                │                   │
       └──────────────┴────────┬───────┴───────────────────┘
                               ▼
                  Production Architecture
                               │
                               ▼
                   Mastery & Capstone

The Production Hardening slice is intentionally orthogonal-it accumulates a hardening/ workspace that, by week 24, is a publishable Cargo template.

Non-Goals

  • This curriculum does not cover web frameworks (Axum/Actix) as primary subjects. They appear only as integration surfaces in Month 5.
  • Game development, GUI, and WASM front-ends are out of scope. Pointers are given for the curious in the prelude.
  • "Rewrite it in Rust" advocacy is explicitly avoided; the reader should finish the program able to argue against using Rust when it is the wrong tool.

Capstone Tracks (pick one in Month 6)

  1. Compiler Track-land a non-trivial PR in rust-lang/rust (e.g., a clippy lint, a diagnostic improvement, or a small MIR transform).
  2. Fintech Track-implement a multi-asset limit-order-book matching engine with sub-microsecond p99 hot-path latency, fuzzed and verified under loom.
  3. Kernel Track-write a Rust character-device driver for rust-for-linux, complete with KUnit tests and a working out-of-tree build.

Detailed track briefs are in the capstone catalog.

Get started

Ready to begin? Start with the Prelude — philosophy, the mental model, and the reading list — then work Month 1 forward. The labs are the unit of mastery: do them.

Print this path

Want to read offline or archive? Open the printable version - every section of this path concatenated into one page, styled for paper. Use your browser's Print → Save as PDF.