Deep Rust Mastery Curriculum (Free Resources Edition)

Philosophy & Approach

This curriculum prioritizes understanding over memorization. You'll build mental models of how Rust works at a fundamental level, enabling you to reason about complex problems rather than pattern-match solutions.

Phase 1: Foundation & Mental Models (4-6 weeks)

Week 1-2: The Ownership Revolution

Goal: Internalize why ownership exists, not just how it works

Resources:

• 📚 The Rust Programming Language - Chapters 1-6


• 📚 Rust By Example - Parallel reading for hands-on practice


• 🎥 Let's Get Rusty - Ownership playlist - Visual explanations


• 🎓 Rustlings - Exercises on ownership, move semantics

Deep Dive Activities:

• Trace memory allocation/deallocation manually on paper for simple programs


• Compare Rust's approach to C++ RAII, garbage collection, and manual memory management


• Read this article on ownership multiple times

Exercise:

• Complete all ownership-related Rustlings exercises


• Build a simple vector-like type from scratch


• 
  Learn Rust With Entirely Too Many Linked Lists - Start with "A Bad Stack"

Reflection: Write explanations of ownership as if teaching a 10-year-old, then a C programmer, then a Python developer

Week 3-4: Borrowing & Lifetimes—The Hard Parts

Goal: Develop intuition for the borrow checker

Resources:

• 📚 The Book - Chapters 7-11


• 📚 Too Many Linked Lists - Continue through all chapters


• 📝 Common Rust Lifetime Misconceptions - Essential reading!


• 🎥 Jon Gjengset - Crust of Rust: Lifetime Annotations
  


• 🎥 Jon Gjengset - Crust of Rust: Subtyping and Variance
  

Deep Dive:

• Manually desugar lifetime elision rules


• Study the borrowing flowchart: when is &T sufficient vs &mut T vs owned T?


• Work through Rust by Practice - Ownership section
  

Projects:

• Build a simple text editor buffer with efficient insertions


• Implement a graph structure with multiple ownership patterns (Rc, RefCell)


• Create a custom iterator that borrows from its parent structure


• Complete Exercism - Rust Track exercises: Clock, Circular Buffer, Doubly Linked List

Week 5-6: Type System Mastery

Goal: Think in types, not just code

Resources:

• 📚 The Book - Chapters 10, 17, 19


• 📝 Rust Design Patterns - All patterns


• 🎥 Jon Gjengset - Crust of Rust: Iterators
  


• 🎥 Jon Gjengset - Crust of Rust: Smart Pointers and Interior Mutability
  


• 📝 Rust API Guidelines - Design principles


• 📝 Abstraction without overhead: traits in Rust
  

Deep Dive:

• Trait objects vs generics: monomorphization costs and tradeoffs


• Marker traits (Send, Sync, Copy, Sized) and their implications


• Associated types vs generic parameters—when to use each


• Read the std::iter module docs completely

Projects:

• Implement a small serialization library using traits (inspired by serde)


• Build a plugin system using trait objects


• Create your own Result-like type with custom error handling


• Study Serde's source code to understand trait magic

Phase 2: Concurrency & Async (6-8 weeks)

Week 7-9: Fearless Concurrency Foundations

Goal: Understand why Rust makes concurrency safe

Resources:

• 📚 The Book Chapter 16 - Fearless Concurrency


• 📚 Rust Atomics and Locks by Mara Bos - FREE ONLINE! Read chapters 1-6


• 🎥 Jon Gjengset - Crust of Rust: Channels
  


• 🎥 Jon Gjengset - Crust of Rust: Atomics and Memory Ordering
  


• 📝 The Rustonomicon - Concurrency
  

Deep Dive:

• How Send and Sync prevent data races at compile time


• Memory ordering: Relaxed, Acquire, Release, SeqCst


• Interior mutability pattern: Cell, RefCell, Mutex, RwLock
  


• Read std::sync module docs thoroughly

Projects:

• Build a thread pool from scratch (follow along with Rust Book Chapter 20)


• Implement a concurrent hash map using RwLock
  


• Create a work-stealing scheduler (study rayon's approach)


• Complete exercises from Rust Atomics and Locks
  

Week 10-12: Async Rust—The Complete Picture

Goal: Understand async from first principles

Resources:

• 📚 Asynchronous Programming in Rust - Official async book


• 📚 Tokio Tutorial - Build mini-Redis (DO THIS!)


• 🎥 Jon Gjengset - Crust of Rust: Async/Await
  


• 🎥 Jon Gjengset - The What and How of Futures and async/await in Rust
  


• 📝 Tokio internals: Understanding Rust's async runtime
  


• 📝 Pin, Unpin, and why Rust needs them
  

Deep Dive:

• What is a Future? Implement your own simple future following this guide
  


• How polling works: Poll::Ready vs Poll::Pending
  


• The Waker API and how runtimes schedule tasks


• Pin and why it exists (this is hard—spend time here)


• Read futures crate docs
  

Critical Understanding:

• Async is about I/O concurrency, not parallelism


• The "function coloring" problem and its implications


• Structured concurrency with select! and join!
  

Required Reading:

• 📝 What Color is Your Function? - Understanding async limitations


• 📝 Async: What is blocking?
  

Week 13-14: Async Ecosystems & Patterns

Goal: Master practical async programming

Resources:

• 📚 Tokio Topics - All advanced topics


• 📝 Tokio's tracing documentation
  


• 🎥 Jon Gjengset - Implementing TCP in Rust - Deep async networking


• 📝 Alice Ryhl's Tokio blog posts - All of them!


• 📚 async-std book - Compare with Tokio

Study:

• Tokio vs async-std vs smol: architectural differences


• Channels: mpsc, broadcast, watch, oneshot


• Async traits and why they're challenging


• Read tokio source code - start with tokio::time
  

Projects:

• Complete the Tokio mini-Redis tutorial fully


• Build an async HTTP server from scratch (without frameworks) - follow Jon Gjengset's stream
  


• Implement a connection pool with timeouts and backpressure


• Create a pub-sub system using Tokio's broadcast channels


• Build a rate limiter using async semaphores

Phase 3: Advanced Patterns & Systems (8-12 weeks)

Week 15-17: Zero-Cost Abstractions

Goal: Write high-level code that compiles to optimal machine code

Resources:

• 📚 The Rust Performance Book - Entire book


• 🎥 Jon Gjengset - Crust of Rust: Sorting Algorithms - Performance patterns


• 📝 Cheap tricks for high-performance Rust
  


• 📝 The Rust Performance Book - Profiling
  


• 📝 Optimization - Rust Language Reference
  

Deep Dive:

• Understanding LLVM IR: use Compiler Explorer (Godbolt) with Rust


• Inlining, devirtualization, and constant folding


• Profile-guided optimization


• Reading assembly output with cargo asm (install with cargo install cargo-show-asm)


• Study criterion.rs for benchmarking

Projects:

• Benchmark different iterator patterns (.map().filter() vs manual loops)


• Optimize hot paths using profiling tools (install cargo-flamegraph)


• Write a zero-allocation parser


• Study serde_json performance and try to beat it


• Complete Exercism Performance-focused exercises
  

Week 18-20: Unsafe Rust & FFI

Goal: Know when and how to break the rules safely

Resources:

• 📚 The Rustonomicon - Read cover-to-cover (seriously!)


• 🎥 Jon Gjengset - Crust of Rust: Unsafe Code
  


• 🎥 Jon Gjengset - Crust of Rust: Lifetime Annotations (revisit)
  


• 📝 Learn Rust the Dangerous Way - LWN articles


• 📝 Unsafe Code Guidelines
  

Deep Dive:

• Undefined behavior and how to avoid it


• Raw pointers and their limitations


• Writing sound unsafe abstractions


• FFI with C libraries


• Study std library unsafe usage - search for unsafe
  

Projects:

• Implement a custom allocator (use std::alloc::GlobalAlloc)


• Create Rust bindings for a C library using bindgen
  


• Build a simple arena allocator


• Study crossbeam's lock-free structures - careful unsafe usage


• Contribute to Miri test cases (undefined behavior detector)

Week 21-23: Macros—Metaprogramming Mastery

Goal: Generate code at compile time elegantly

Resources:

• 📚 The Little Book of Rust Macros - Complete guide


• 📚 The Rust Reference - Macros
  


• 🎥 Jon Gjengset - Crust of Rust: Declarative Macros
  


• 🎥 Jon Gjengset - Crust of Rust: Procedural Macros
  


• 📝 Procedural Macros Workshop - Hands-on exercises

Deep Dive:

• Declarative macros: pattern matching on syntax


• Procedural macros: derive, attribute, function-like


• Hygiene and macro expansion order


• Use cargo expand to see macro output


• Study syn and quote crates

Projects:

• Complete dtolnay's proc-macro-workshop - All 5 projects


• Write a custom derive macro for serialization


• Build a builder pattern generator (study derive_builder)


• Create a DSL using macros (e.g., SQL query builder)


• Study serde_derive source
  

Week 24-26: Error Handling & Observability

Goal: Build production-ready error handling

Resources:

• 📚 Rust Book - Error Handling
  


• 📝 Error Handling in Rust - Andrew Gallant's guide


• 📝 Rust Error Handling - Modern patterns


• 📚 Read docs for: anyhow, thiserror, eyre
  


• 📚 Tracing documentation - Structured logging


• 🎥 Jon Gjengset - Error Handling in Rust
  

Study:

• Error trait design: std::error::Error
  


• When to use anyhow vs thiserror
  


• Structured logging with tracing
  


• Distributed tracing concepts

Projects:

• Design a comprehensive error type for a multi-layer application


• Instrument async code with tracing spans


• Build a metrics collection system using tracing-subscriber
  


• Study tokio-tracing examples
  


• Create error report with full context chain (study eyre and color-eyre)

Phase 4: Real-World Systems (Ongoing)

Domain-Specific Mastery

Systems Programming:

Resources:

• 📚 Writing an OS in Rust - Complete tutorial series


• 📚 Embedded Rust Book
  


• 🎥 Jon Gjengset - Implementing TCP
  


• Study redox-os source - OS written in Rust

Projects:

• Follow Writing an OS in Rust completely


• Implement a file system in userspace (FUSE)


• Build a network protocol from scratch


• Contribute to rust-lang std library
  

Web & Backend:

Resources:

• 📚 Actix Web Documentation
  


• 📚 Axum Documentation
  


• 📚 Rocket Guide
  


• 🎥 Let's build a web server from scratch - Jon Gjengset


• 📝 Command Line Apps in Rust
  

Projects:

• Build a complete REST API with Axum


• Implement WebSocket server with state management


• Create a simple database driver from scratch (study tokio-postgres)


• Build a web scraper with reqwest and scraper
  


• Study rustls source - TLS implementation

Blockchain/DeFi:

Resources:

• 📚 Solana Cookbook - Free comprehensive guide


• 📚 Anchor Book - Framework documentation


• 📚 Solana Program Library - Study source code


• 📝 Understanding Solana's Account Model
  


• 📝 Borsh Specification
  

Projects:

• Deep dive into Solana's runtime and BPF


• Study Anchor framework internals (read source)


• Implement AMM math from scratch (constant product, stable swap)


• Build cross-program invocation patterns


• Study successful programs: Serum DEX, Mango Markets
  


• Understand account rent and program derived addresses

Performance Engineering:

Resources:

• 📚 The Rust Performance Book (revisit)


• 📝 Rust SIMD Guide
  


• 📝 Cache-Friendly Code
  


• 📝 Study ripgrep source - peak Rust performance

Projects:

• Profile real applications with perf, cargo flamegraph
  


• Optimize memory allocations using heaptrack
  


• Study cache-friendly data structures


• Learn SIMD programming with std::simd
  


• Contribute performance improvements to open-source Rust projects

Continuous Learning Practices

Daily Habits (Pick 2-3)

1. 
   

   Read source code (30 min): Study well-written Rust projects

   
   
   
   
   
   • 
     Essential repos to study:
     
     
     
     
     • 
       tokio - Async runtime
     
     
     • 
       serde - Serialization
     
     
     • 
       clap - CLI parser
     
     
     • 
       axum - Web framework
     
     
     • 
       ripgrep - Fast grep
     
     
     • 
       bat - Better cat
     
     
     • 
       fd - Better find
     
     
     
     
   
   
   
   


2. 
   

   Write code (1-2 hours): Build small experiments

   
   
   
   
   
   • 
     Rustlings daily
   
   
   • Implement algorithms in Rust
   
   
   • Recreate crates you use to understand them
   
   
   
   


3. 
   

   Teach others:

   
   
   
   
   
   • Answer questions on Rust Users Forum
     
   
   
   • Write blog posts (host free on GitHub Pages)
   
   
   • Contribute to Rust by Example
     
   
   
   
   

Weekly Activities

• 
  

  Code review: Review Rust PRs on GitHub

  
  
  
  
  
  • Find projects with "good first issue" label
  
  
  • Study how maintainers review code
  
  
  
  
  
  



• 
  
  

  Deep dive: Pick one concept and understand it completely

  
  
  
  
  
  • Use The Book, Rustonomicon, or Reference
    
  
  
  
  
  
  



• 
  
  

  Build something: Work on a meaningful project

  
  
  
  
  
  • Ideas: CLI apps, web services, games
  
  
  
  
  
  

Monthly Goals

• 
  

  Read papers:

  
  
  
  
  
  • Rust papers/talks
  
  
  • Distributed systems papers from Papers We Love
    
  
  
  
  
  
  



• 
  
  

  Contribute to OSS:

  
  
  
  
  
  • Find Rust projects needing help on GitHub
    
  
  
  • Start with documentation improvements
  
  
  
  
  
  



• 
  
  

  Write:

  
  
  
  
  
  • Blog posts (free: dev.to, Medium, GitHub Pages)
  
  
  • Share learnings on r/rust
    
  
  
  
  
  
  

Essential Free Resources Summary

📚 Must-Read Books (All Free!)

1. The Rust Programming Language


2. Rust By Example


3. The Rustonomicon


4. Rust Atomics and Locks


5. Asynchronous Programming in Rust


6. The Little Book of Rust Macros


7. Too Many Linked Lists


8. The Rust Performance Book

🎥 Video Series

• 
  Jon Gjengset - Crust of Rust - THE best advanced content


• 
  Let's Get Rusty - Great for beginners


• 
  No Boilerplate - Energizing short videos