Rust Learning Lab is a practical path through Rust: read a focused explanation, run a small program, change it, and use the compiler's feedback to deepen the idea. It supports both first-time Rust learners and experienced developers moving from Java, Python, Go, or C++.
The repository is actively growing. Most foundations, applications, intermediate material, and design-pattern examples are ready for review; some advanced projects and production topics are still Draft or Planned. Content status explains the evidence behind each area, and the roadmap records the remaining work.
Start with 00-setup-and-basics, then work through 01-core-fundamentals, 02-standard-library, and 03-tooling-and-quality. This route establishes the language, ownership model, standard library, testing, and everyday development tools.
Move through 04-simple-programs and 05-cli-and-console-games to combine I/O, algorithms, state, and user interaction. Continue to 06-intermediate-rust for ownership and borrowing, traits, generics, enums, and lifetimes.
Use 11-language-specific-tracks alongside the core path. The Java, Python, Go, and C++ guides connect familiar language features to Rust's ownership, error-handling, and type-system model without duplicating the core lessons.
| Journey | Modules | What you will practice |
|---|---|---|
| Foundations | 00–03 | Syntax, ownership, standard types, testing, documentation, and tooling |
| Applied Rust | 04–05 | Command-line programs, file handling, algorithms, state, and games |
| Type-system depth | 06 | Traits, generics, enums, pattern matching, lifetimes, and optional supplementary review |
| Advanced reference | 07–08 | Networking, APIs, WebAssembly, macros, performance, and design patterns |
| Projects and production | 09–10 | Multi-file programs, organization, deployment, profiling, and systems topics |
The learning path gives the same sequence in a compact format. Module 06 also includes supplementary review material; it is useful after the primary sequence and remains Draft until it receives its own validation coverage.
For the detailed beginner route, including stage checkpoints, use From Zero: the canonical Rust path.
Install the stable Rust toolchain with rustup, including rustfmt and clippy, plus Git and Make. The included toolchain file selects the repository's Rust channel and components.
git clone https://github.com/SaumilP/rust-learning-lab.git
cd rust-learning-lab
cd 00-setup-and-basics/hello_world
cargo runMany concept modules use standalone Rust files. Run their Makefile from the module directory:
cd 01-core-fundamentals
make list
make run EXAMPLE=control_flow/examples/loops.rs
make check
make cleanmake check formats, compiles, tests, and documents the module's checked examples. Generated build/ and target/ directories are disposable. Some exercises intentionally begin with broken code; read the problem statement before treating those compiler errors as repository defects.
For a Cargo package or workspace, run Cargo from the directory containing its Cargo.toml:
cd 04-simple-programs
cargo run -p calculator
cargo test --workspace- Read the topic
README.mdandkey_takeaways.md. - Run the example before changing it.
- Predict a small change, then test that prediction.
- Repair the related exercise using compiler feedback.
- Apply the idea in a program or project before moving on.
Corrections, clearer explanations, focused examples, exercises, and tests are welcome. Read CONTRIBUTING.md for the learning-content standards and validation commands, CODE_OF_CONDUCT.md for community expectations, and SECURITY.md for security reporting.
This project is available under the MIT License.