Microsoft's RustTraining: A Seven-Book Curriculum for Learning Rust by Background

What RustTraining Actually Covers

The repository is not a single book but a collection of seven training courses, each rendered as a separate mdbook. The README groups them into five levels: Bridge, Deep Dive, Advanced, Expert, and Practices. The Bridge books target programmers coming from C/C++, C#, Java, Swift, or Python. The Deep Dive book is Async Rust, covering Tokio, streams, and cancellation safety. The Advanced book, Rust Patterns, goes into Pin, allocators, lock-free structures, and unsafe code. The Expert book, Type-Driven Correctness, covers type-state, phantom types, and capability tokens. Finally, Rust Engineering Practices covers build scripts, cross-compilation, CI/CD, and Miri. Each book has 15 to 16 chapters, with Mermaid diagrams, editable Rust playgrounds, exercises, and full-text search. That structure makes it a curriculum, not a reference manual. The disclaimer in the README is explicit: these books are training material, not an authoritative reference, and readers should verify critical details against the official Rust documentation and the Rust Reference.

How the Books Are Organized and What That Means for Learning

The level system is a deliberate pedagogical choice. Bridge books assume you already know another language, so they map concepts like move semantics and RAII from C++, or ownership from C# and Java, rather than starting from zero. The Deep Dive and Advanced books assume you have basic Rust fluency and want to go deeper into a subsystem. The Expert book on type-driven correctness pushes into type-level techniques that most Rust developers will never use daily. That progression is useful if you know exactly where you are. But it also means the material is not a linear path from beginner to expert. You pick a book based on your background and interest, not on a fixed sequence. For example, a Python programmer should start with the Python book, not the C/C++ book, even though both are Bridge level. The README makes this clear by saying 'Pick the book that matches your background.' The downside is that you might miss cross-cutting concepts if you only read one book. The repository does not describe a recommended order across books, so you have to decide yourself.

Getting It Running: Commands and Configuration

The README gives concrete commands for local preview and contribution. First, install Rust via rustup, then run `cargo install mdbook@0.4.52 mdbook-mermaid@0.14.0`. The version pins are explicit, which is good for reproducibility but also means you must have those exact versions or the build may fail. After cloning the repository, you can build all books with `cargo xtask build`, which outputs to `site/`. To serve locally, use `cargo xtask serve` and open `http://localhost:3000`. For deployment to GitHub Pages, `cargo xtask deploy` builds into `docs/`. The repository auto-deploys on push to `main` via `.github/workflows/pages.yml`, so you do not need manual steps if you are a maintainer. If you want to work on a single book, you can `cd c-cpp-book && mdbook serve --open`. The `cargo xtask` commands are a custom task runner, so you need a Rust toolchain to use them. The README also mentions that the rendered books are available at `https://microsoft.github.io/RustTraining/` with sidebar navigation and search, which is the easiest way to read without installing anything.

Where This Material Falls Short

The most obvious limitation is the disclaimer itself: the books are not authoritative. If you are using them to learn unsafe Rust or type-level tricks, you must cross-check with the official documentation. That is a real cost, especially for topics like Pin and allocators where subtle mistakes are easy. Another limitation is the lack of a single recommended path. The README tells you to pick a book by background, but it does not tell you what to read after the Bridge book, or whether you should read the Async book before the Patterns book. You are left to guess. Also, the material is text-based with Mermaid diagrams and playgrounds, but there is no video or interactive IDE integration beyond the editable playgrounds. For some learners, that is fine. For others, a video course or a live coding environment might be more effective. Finally, the repository is not a reference, so if you need a quick lookup of a specific trait or syntax, you are better off with the Rust Book or Rust by Example. The README explicitly points to those resources as inspirations, but they are separate projects.

A Real Alternative: The Rust Programming Language Book

The most direct alternative is the official Rust Book, titled 'The Rust Programming Language', which the README lists as the foundation everything builds on. The difference in approach is significant. The Rust Book is a single, linear narrative that starts from installation and basic syntax, then moves through ownership, structs, enums, modules, error handling, and so on. It is designed for a reader with no prior Rust experience and no specific language background. RustTraining, by contrast, is a branched curriculum with separate entry points for C/C++, C#, and Python programmers. That means the Rust Book is a better choice if you want a single authoritative source that you can read cover to cover. RustTraining is better if you want to skip the basics you already know and focus on the parts that are different in Rust. The Rust Book is also maintained by the Rust project itself, so it tracks language changes closely. RustTraining is a training resource from Microsoft, and while it is not archived, the README does not state a maintenance cadence or a version policy. That is a meaningful difference for a learner who wants current information.

Licence and Maintenance Considerations

The repository is dual-licensed. The code is under the MIT License, while the documentation is under the Creative Commons Attribution 4.0 International (CC-BY-4.0) license. That means you can reuse the text for your own training materials, but you must give attribution as required by CC-BY-4.0. The README also includes a trademark notice: Microsoft trademarks and logos are subject to Microsoft's Trademark & Brand Guidelines, and modified versions must not imply Microsoft sponsorship. That is a practical constraint if you plan to fork the repository and redistribute it. The README does not give a last push date or a release history, so you cannot confirm how actively it is maintained. The auto-deploy workflow suggests the project is live, but there is no explicit maintenance promise. For a training resource, that means you should check the GitHub Pages site for the most recent updates before relying on it for a course. The pinned mdbook versions (0.4.52 and 0.14.0) are specific, which helps reproducibility but also means you may need to update them if you use a newer Rust toolchain.

Editorial conclusion

Adopt RustTraining if you are a programmer coming from C, C++, C#, Java, Swift, or Python and want a structured path that respects your existing knowledge, or if you are an experienced Rustacean looking for deep dives into async, Pin, allocators, and type-state. Skip it if you need a single authoritative reference: the README itself says to verify critical details against the official Rust documentation and the Rust Reference. Before committing, verify that the book for your background matches your target domain: the C/C++ book covers embedded and no_std, but the Python book focuses on GIL-free concurrency and static typing, so check the table of contents on the GitHub Pages site. Also confirm that the mdbook toolchain versions (mdbook 0.4.52 and mdbook-mermaid 0.14.0) work in your environment, since the build depends on those exact pinned versions.

Official sources

1. Official README
2. Project repository