A self-contained, offline-friendly, 0-to-100 modular Rust learning sandbox.
Rust.Stack takes you from zero Rust knowledge to job-ready across every major Rust specialization — backend, async/infra, systems/embedded, CLI/networking, WASM/frontend, game dev, blockchain — and finishes with interview and portfolio readiness.
Built for programmers comfortable with general programming concepts in some language
(Python, JS, Java, C++, etc.) but with zero Rust experience.
No website. No toolchain wizard. No build step. git clone and go.
- ✨ What Makes This Different
- 🗺️ Curriculum at a Glance
- 🏆 Capstones
- ⚡ Quick Start
- 📋 Prerequisites
- 📖 How to Use This Repo
- 🗂️ Repository Structure
- ❓ FAQ
- ✅ Progress Tracking
- 📜 License & Contributing
- 🔁 CI
| 🧵 Strictly linear | Module 000 → Module 100, in order. No branching, no choice paralysis. Every specialization gets a full 10-module block in sequence. |
| 🛠️ 100% hands-on | Every module ships with a broken/incomplete Cargo crate. You fix it until cargo test passes. Every 10th module is a larger capstone project. |
| 👁️ Solutions are visible | Every module has a solutions/ folder with the reference implementation, sitting alongside the exercise. No paywalls, no spoiler tags. |
| 🏗️ Idiomatic & production-grade | ?, iterators, thiserror, anyhow, current-edition idioms throughout. rustfmt and clippy clean. |
| 📴 Runs offline | Once dependencies are cached, everything — READMEs, exercises, solutions — works without internet. |
| 🎯 Interview-ready finish | The final block covers DSA in Rust, system design, mock interviews, open source contribution, and portfolio building. Capstone 10 is a deliberate portfolio piece. |
92 modules + 10 capstones, organized into 10 blocks:
| Block | Modules | Focus |
|---|---|---|
 |
001–009 | Variables, ownership, borrowing, structs, enums, modules |
 |
011–019 | Collections, error handling, generics, traits, lifetimes, testing |
 |
021–029 | Closures, iterators, pattern matching, trait objects, smart pointers |
 |
031–039 | Threads, Mutex/Arc, channels, unsafe Rust, macros, Cargo |
 |
041–049 | Tokio runtime, async I/O, streams, pinning, structured concurrency |
 |
051–059 | Memory layout, FFI, profiling, benchmarking, SIMD, embedded |
 |
061–069 | Axum, REST APIs, sqlx, JWT auth, middleware, Actix-web, Docker |
 |
071–079 | clap, ratatui, TCP/UDP, gRPC, message queues, distributed systems |
 |
081–089 | WebAssembly, Leptos, Bevy ECS, embedded revisited, smart contracts |
 |
091–100 | DSA in Rust, system design, mock interviews, portfolio, open source |
Each block ends with a capstone project. Capstone 10 is a full-stack Rust job-ready project — the thing you point to in applications.
# 1. Install Rust (if you haven't already)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# 2. Clone and enter the repo
git clone https://github.com/Amogh-007-Rin/RUST.STACK.git
cd RUST.STACK
# 3. Build everything (optional — verifies your setup works)
cargo check --workspace
# 4. Start at Module 000
cat modules/module-000-orientation/README.mdTip
Estimated completion time: 3–6 months at ~10 hours/week, assuming you work through every module and capstone.
- 🦀 Rust via rustup — stable toolchain, pinned by
rust-toolchain.toml - 🧩 rust-analyzer — recommended: VS Code with the rust-analyzer extension
- 🔧 Git
- 🧠 Familiarity with programming fundamentals in any language (variables, functions, loops, basic data structures)
Note
Everything installs from the internet once; after that, all content, examples, and exercises are fully offline.
📄 See docs/SETUP.md for detailed setup instructions.
The curriculum is strictly linear: Module 000 → Module 100, with a capstone project at the end of every 10-module block.
modules/module-042-the-tokio-runtime/
├── README.md ← Read this first. Teaches the concept from scratch.
├── exercises/ ← Broken/incomplete code. Your job: fix it.
│ ├── Cargo.toml
│ ├── src/lib.rs ← Contains // TODO(module-042): ... comments
│ └── tests/ ← Tests define "done"
└── solutions/ ← Reference implementation. Peek when stuck.
├── Cargo.toml
├── src/lib.rs
└── tests/ ← Identical tests, all passing
- 📘 Read the module's
README.md— it explains the concept from scratch with prose and code examples. - 🔍 Open the exercise crate in your editor. Find the
TODO(module-XXX)comments. - 🛠️ Fix the code until the tests pass:
cargo test -p module-042-exercises # should start RED, end GREEN
- 👀 Peek at
solutions/if you get truly stuck. No shame — the reference is there on purpose. - ✅ Verify your work:
./scripts/verify_module.sh 042 # runs fmt, clippy, and tests - ☑️ Check the box in the curriculum map below and move on.
Same pattern, just bigger. Each capstone lives in capstones/capstone-NN-*/ with
starter/ (your work) and solution/ (reference). They span 4–8 hours each and
integrate everything from the preceding block.
| Command | What it does |
|---|---|
cargo test -p module-XXX-exercises |
Run tests for one module's exercise |
cargo test -p module-XXX-solutions |
Run tests for one module's solution |
cargo test |
Run tests for all solution crates |
./scripts/verify_module.sh 042 |
fmt + clippy + test for one module |
📚 Full walkthrough, module anatomy, and FAQ: docs/HOW_TO_USE.md.
Rust.Stack/
├── README.md
├── Cargo.toml # Workspace root (glob members)
├── rust-toolchain.toml # Pinned stable toolchain
├── CONTRIBUTING.md
├── LICENSE # MIT
├── docs/
│ ├── SETUP.md
│ └── HOW_TO_USE.md
├── scripts/
│ ├── new_module.sh # Scaffolds a new module
│ ├── verify_module.sh # fmt + clippy + test for one module
│ └── check_progress.sh # Reports completion %
├── modules/
│ ├── module-000-orientation/
│ ├── module-001-toolchain-and-first-program/
│ ├── ...
│ └── module-100-final-capstone-support/
└── capstones/
├── capstone-01-contact-book-cli/
├── ...
└── capstone-10-full-stack-job-ready-project/
I already know some Rust. Can I skip ahead?
Yes. Each module's README lists prerequisites. If you're comfortable with a topic, skim the README, run the solution tests to confirm, and move on. The capstones are especially useful for validation even if you skip blocks.
Do I need to be online?
No. Clone the repo once, run cargo fetch to cache dependencies, and you're
fully offline from that point forward.
Can I contribute?
Absolutely. See CONTRIBUTING.md for the folder shape requirements, content guidelines, and the acceptance bar (fmt, clippy, tests must be clean). PRs welcome for new modules, improvements to existing ones, or bug fixes.
What if a module's solution tests don't pass for me?
Make sure you're on the stable toolchain (rustup show). The repo pins its
toolchain in rust-toolchain.toml. If you're on a different Rust version, some
dependencies may not compile. File an issue if the problem persists.
Is there a completion certificate or credential?
No. This is a plain git repo, not a platform. The portfolio project (Capstone 10) and the capstones you've built serve as your credential.
How long does it take?
Roughly 3–6 months at ~10 hours/week. Each module takes 45–90 minutes; each capstone takes 4–8 hours. The curriculum has 101 slots (92 modules + 10 capstones, counting Module 000 and Capstone 10).
Tick the checkboxes below as you complete modules and capstones. Run
./scripts/check_progress.sh to see your completion percentage.
🟥 Block A — Foundations I 001–009 → Capstone 01
- Module 001 — Toolchain & Your First Program
- Module 002 — Variables, Mutability & Data Types
- Module 003 — Functions & Control Flow
- Module 004 — Ownership Part 1
- Module 005 — Ownership Part 2: Borrowing & References
- Module 006 — Slices & Strings
- Module 007 — Structs
- Module 008 — Enums & Pattern Matching
- Module 009 — Modules, Crates & Packages
- Capstone 01 — Contact Book CLI
🟧 Block B — Foundations II 011–019 → Capstone 02
- Module 011 — Common Collections I:
Vec<T> - Module 012 — Common Collections II:
HashMap&HashSet - Module 013 — Error Handling I:
panic!&Result - Module 014 — Error Handling II:
?, Custom Errors &thiserror - Module 015 — Generics
- Module 016 — Traits I: Defining & Implementing
- Module 017 — Traits II: Bounds & Trait Objects
- Module 018 — Lifetimes
- Module 019 — Testing in Rust
- Capstone 02 — Inventory Management CLI
🟨 Block C — Intermediate Rust I 021–029 → Capstone 03
- Module 021 — Closures
- Module 022 — Iterators I: The
IteratorTrait - Module 023 — Iterators II: Combinators
- Module 024 — Advanced Pattern Matching
- Module 025 — Advanced Traits
- Module 026 — Trait Objects & Dynamic Dispatch
- Module 027 — Design Patterns in Rust
- Module 028 — Smart Pointers I:
Box,Deref,Drop - Module 029 — Smart Pointers II:
Rc&RefCell - Capstone 03 — In-Memory Graph Library
🟩 Block D — Concurrency, Unsafe & Macros 031–039 → Capstone 04
- Module 031 — Concurrency I: Threads
- Module 032 — Concurrency II:
Mutex&Arc - Module 033 — Concurrency III: Channels
- Module 034 — Concurrency IV:
Send/Sync& Atomics - Module 035 — Unsafe Rust I
- Module 036 — Unsafe Rust II
- Module 037 — Macros I: Declarative
- Module 038 — Macros II: Procedural
- Module 039 — Cargo Deep Dive
- Capstone 04 — Multithreaded Log Processor
🟦 Block E — Async Rust 041–049 → Capstone 05
- Module 041 — Async Fundamentals
- Module 042 — The Tokio Runtime
- Module 043 — Async I/O
- Module 044 — Async Synchronization
- Module 045 — Streams
- Module 046 — Pinning & Async Internals
- Module 047 — Structured Concurrency & Cancellation
- Module 048 — Error Handling in Async Code
- Module 049 — Async Patterns & Pitfalls
- Capstone 05 — Concurrent Rate-Limited Web Crawler
🟪 Block F — Systems Programming & Performance 051–059 → Capstone 06
- Module 051 — Memory Layout Deep Dive
- Module 052 — FFI I: Calling C from Rust
- Module 053 — FFI II: Calling Rust from C
- Module 054 — Performance Profiling
- Module 055 — Benchmarking with Criterion
- Module 056 — Zero-Cost Abstractions & Optimization
- Module 057 — SIMD & Low-Level Optimization
- Module 058 — Introduction to Embedded Rust
- Module 059 — Embedded Rust Hands-On
- Capstone 06 — Benchmarked Data Processing Library
🟫 Block G — Backend Web Development 061–069 → Capstone 07
- Module 061 — HTTP & Web Fundamentals in Rust
- Module 062 — Axum Fundamentals
- Module 063 — Building REST APIs with Axum
- Module 064 — Database Integration with
sqlx - Module 065 — Authentication & Authorization
- Module 066 — Middleware & the Tower Ecosystem
- Module 067 — Actix-web
- Module 068 — Testing Web Services
- Module 069 — Deployment & Observability
- Capstone 07 — Task Management API
⬛ Block H — CLI, Networking & Distributed Systems 071–079 → Capstone 08
- Module 071 — Building CLI Tools I:
clap - Module 072 — Building CLI Tools II: Config, Errors & Polish
- Module 073 — Terminal UIs with
ratatui - Module 074 — Raw Networking
- Module 075 — Serialization Deep Dive
- Module 076 — gRPC with Tonic
- Module 077 — Distributed Systems Concepts I
- Module 078 — Distributed Systems II: Key-Value Store
- Module 079 — Message Queues & Event-Driven Systems
- Capstone 08 — Distributed Key-Value Store
🟣 Block I — WASM, Frontend, Game Dev, Embedded & Blockchain 081–089 → Capstone 09
- Module 081 — Introduction to WebAssembly
- Module 082 —
wasm-bindgen& JS Interop - Module 083 — Rust Frontend with Leptos
- Module 084 — WASM Performance Use Cases
- Module 085 — Game Development with Bevy
- Module 086 — Bevy Deep Dive: 2D Game
- Module 087 — Embedded Rust Revisited
- Module 088 — Blockchain & Smart Contracts in Rust
- Module 089 — Comparing Rust Career Specializations
- Capstone 09 — 2D Game Compiled to WebAssembly
🔴 Block J — Interview Prep, DSA & Career Readiness 091–100 → Capstone 10
- Module 091 — Data Structures in Rust I
- Module 092 — Data Structures in Rust II
- Module 093 — Algorithms in Rust
- Module 094 — Rust-Specific Interview Questions
- Module 095 — System Design with Rust
- Module 096 — Open Source Contribution
- Module 097 — Building Your Portfolio
- Module 098 — Mock Interview & Code Review Practice
- Module 099 — Advanced Topics & Staying Current
- Module 100 — Final Capstone Support
- Capstone 10 — Full-Stack Rust Job-Ready Project
| 📄 License | MIT |
| 🤝 Contributing | See CONTRIBUTING.md — required folder shapes, content guidelines, and the acceptance bar (fmt, clippy, tests clean, always). |
Built with 🦀, one module at a time. Star ⭐ this repo if it's helping you learn Rust.