28 lessons / 5 stages / one complete path
The curriculum.
Work through the lessons in order, or return to a topic when you need it.
Learn the foundations
Write your first program, learn ownership, and build an event counter.
Set up Rust
Install Rust, find your way around a Cargo project, and run your first example.
Values, functions, and control flow
Write functions, choose between cases, and handle numbers that reach their limits.
Ownership, places, and moves
Learn what moves, what gets copied, and when a borrow is enough.
Borrowing and reborrowing
Use shared and exclusive references, and see when a borrow ends.
Strings, slices, and collections
Work with UTF-8 text and choose when collections should own or borrow data.
Structs, enums, and program states
Represent your data with structs and enums, and reject invalid states.
Errors as part of the interface
Use Option, Result, and useful error messages to handle different kinds of failure.
Stage build: the first event counter
Build a working event counter with loops, matching, and borrowed text.
Build reliable programs
Design functions that borrow data, handle errors, limit input, and test the results.
Lifetimes describe relationships
Connect borrowed results to their inputs without trying to extend the life of data.
Traits and reusable interfaces
Use standard traits, associated types, and static or dynamic dispatch.
Iterators and closures
Follow iterator items, closure captures, and errors through your code.
Stage build: a bounded streaming library
Build a library that parses records as it reads them and limits buffer growth.
Cargo, modules, and dependency boundaries
Understand packages, modules, features, and the dependencies your program builds.
Tests, compiler errors, and verification tools
Test expected behavior and failures, then use compiler checks and Clippy to catch more mistakes.
Understand concurrent work
Share data safely, coordinate threads, and learn how futures and runtimes work.
Interior mutability and shared ownership
Choose between reference counting, runtime borrow checks, and locks.
Threads, Send, and Sync
Move or borrow data across threads, then handle completion and failure.
Channels, locks, and shutdown
Pass work through channels, protect shared data, and shut down without deadlocks.
Atomics and memory ordering
Use atomic counters and understand why sharing other data needs more than a flag.
Futures before runtimes
Learn how polling and wakeups work before adding an async runtime.
Tokio tasks, blocking, and cancellation
Run Tokio tasks, limit queued work, and handle blocking calls and cancellation.
Work with systems code
Understand pinning and unsafe code, measure performance, and follow work on Rust.
Pin and async traits
Learn what pinning protects and how to return futures through a trait object.
Stage build: process records with async tasks
Send records through a bounded queue and keep one task in charge of the counts.
Unsafe boundaries and soundness
Review a small unsafe function, explain its safety rules, and check it with Miri.
Measure performance and resource use
Measure speed and memory use before changing how the program works.
Stable Rust and work in progress
Tell stable features apart from nightly experiments and plans that may change.
FFI, serialization, and public contracts
Define ownership, data formats, and errors when calling code outside Rust.
Ship and maintain
Install your tool, check its public API, and learn how to release updates.