Rust roadmap

Every topic on the community Rust developer roadmap (roadmap.sh/rust), in the order this course teaches it.

1. Introduction

What Rust is, why companies adopt it, and getting set up.

• What is Rust? (Hello, Rust)
• Why use Rust? (Hello, Rust, Ownership)
• Installing Rust and Cargo (Hello, Rust)
• IDEs and the Rust toolchain (Debugging, Docs and Tooling)
• The Rust Playground (Hello, Rust)

2. Language basics

Syntax and semantics, the building blocks of every program.

• Variables, data types and constants (Variables and Mutability, Numbers, Booleans and Characters)
• Control flow and constructs (Control Flow)
• Functions and method syntax (Functions, Methods)
• Pattern matching and destructuring (Enums and Option, Patterns and matching)
• Reading input (Reading Input)

3. Constructs

Rust's tools for modeling data and behavior.

• Structs (Structs)
• Impl blocks (Methods)
• Enums (Enums and Option)
• Traits (Traits)

4. Data structures

The standard library's types and collections, and when to use each.

• Integers, floats, booleans and characters (Numbers, Booleans and Characters)
• Tuples and arrays (Tuples, Arrays and a First Vec)
• Strings (Working with Text, Strings in depth)
• Vectors (Vectors)
• HashMap and HashSet (HashMaps and sets)
• BTreeMap and BTreeSet (HashMaps and sets, Stacks, Queues, Heaps and Ordered Maps)
• Stack, queue, binary heap and LinkedList (Stacks, Queues, Heaps and Ordered Maps)
• Rc, Arc, Mutex, RwLock and channels (Smart Pointers, Sharing data between threads)

5. Ownership system

The idea that makes Rust memory-safe without a garbage collector.

• Ownership rules and memory safety (Ownership)
• Borrowing, references and slices (Borrowing, Slices)
• Deep dive: stack vs heap (Ownership, Smart Pointers)

6. Error handling

No exceptions, no nulls. Errors are values the compiler makes you handle.

• Option and Result (Enums and Option, Error Handling with Result)
• Propagating errors with the ? operator (Error Handling with Result)
• Custom error types and traits (Custom Error Types)
• Errors in applications (anyhow, thiserror) (Error Handling at Work with thiserror and anyhow)

7. Modules and crates

Organizing code, using dependencies and publishing your own.

• Code organization and namespacing (Modules, Crates and Cargo)
• Dependency management and Cargo.toml (Modules, Crates and Cargo, Debugging, Docs and Tooling)
• Publishing on crates.io (Modules, Crates and Cargo)

8. Traits and generics

Abstraction without runtime cost.

• Trait definitions and implementations (Traits, Standard Library Traits)
• Generics (Generics)
• Trait bounds and associated types (Generics, Advanced Traits)
• Trait objects and dynamic dispatch (Trait Objects)
• Advanced generics and type-level programming (Advanced Traits)

9. Lifetimes and the borrow checker

How Rust proves every reference is valid.

• Explicit lifetime annotations (Lifetimes)
• Lifetime elision rules (Lifetimes)
• Covariance and contravariance (Lifetimes, Advanced Traits)

10. Functional Rust

Closures and iterators, the way idiomatic Rust is written.

• Closures (Closures)
• Iterators (Iterators)

11. Smart pointers and testing

Heap allocation, shared ownership, and proving your code works.

• Box, Rc and RefCell (Smart Pointers)
• Unit and integration testing (Testing)
• Mocking and property-based testing (Testing)

12. Concurrency and parallelism

Fearless concurrency, from threads to async.

• Threads (Threads)
• Channels and message passing (Sharing data between threads)
• Atomic operations and memory barriers (Sharing data between threads)
• Futures and async/await (Async Rust with Tokio)

13. Macros and metaprogramming

Code that writes code.

• Declarative macros with macro_rules! (Macros)
• Procedural macros and custom derive (Macros)
• Domain-specific languages (Macros)

14. Unsafe Rust and performance

Going below the safe abstractions, and making code fast.

• Unsafe Rust and FFI (Unsafe Rust)
• Performance and profiling (Performance)
• Benchmarking with criterion (Performance)

15. Debugging and documentation

The tools that make you productive.

• Debugging (dbg!, rust-gdb, rust-lldb) (Debugging, Docs and Tooling)
• Documenting with rustdoc (Debugging, Docs and Tooling, Testing)
• rustfmt, clippy and CI (Debugging, Docs and Tooling)
• Logging and tracing (Debugging, Docs and Tooling)

16. The ecosystem at work

The libraries Rust teams reach for every day.

• Serialization with serde (JSON and Serialization with serde)
• CLI utilities (clap) (Building Command-Line Tools)
• Async runtime (Tokio) (Async Rust with Tokio)
• Web development (axum) (Web Services and JSON APIs)
• Networking (hyper, reqwest) (Web Services and JSON APIs)
• Databases and ORMs (SQLx, Diesel, rusqlite)
• Idiomatic patterns and code review (Design Patterns and Idioms)

17. Algorithms and interviews

Classic problems, solved the Rust way.

• Collections for algorithms (Stacks, Queues, Heaps and Ordered Maps)
• Searching, sorting and complexity (Searching, Sorting and Classic Techniques)
• Recursion and dynamic programming (Recursion and Dynamic Programming)
• Graphs and trees (Graphs and Trees)
• Capstone (Capstone: Real Tickets)

18. Specializations

Where Rust goes next. These are beyond this course; each has an excellent official guide.

• WebAssembly (wasm-bindgen, wasm-pack)
• Embedded systems (embedded-hal)
• Game development (Bevy, macroquad)
• GUI applications (Tauri, egui, iced)
• Cryptography (ring, RustCrypto)