# microsoft/rusttraining

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/microsoft-rusttraining).**

14,636 stars · 1,147 forks · Rust · MIT

## Links

- GitHub: https://github.com/microsoft/RustTraining
- awesome-repositories: https://awesome-repositories.com/repository/microsoft-rusttraining.md

## Description

This project is a structured Rust programming curriculum and systems programming course designed to take learners from beginner to expert levels. It provides a comprehensive set of training materials focused on mastering the core syntax, idioms, and technical foundations of the Rust language.

The project features a specialized language transition framework that maps concepts from C++, managed languages, and dynamic typing to Rust idioms. This allows developers from different ecosystems to translate architectural patterns and memory models into idiomatic Rust.

The training covers a broad range of high-level capabilities, including asynchronous programming, memory safety and ownership, and type-level design. It also provides guidance on professional engineering practices such as cross-compilation, build script configuration, and the creation of automated delivery pipelines.

Learning is supported through interactive materials, practical exercises, and guided projects such as building command-line applications and developing for bare metal environments.

## Tags

### Education & Learning Resources

- [Programming Language Curricula](https://awesome-repositories.com/f/education-learning-resources/educational-resources/courses-training-certifications/courses-structured-learning/computer-science-curricula/programming-language-curricula.md) — Offers a structured curriculum for mastering the Rust language, from beginner fundamentals to expert engineering practices. ([source](https://github.com/microsoft/rusttraining#readme))
- [Asynchronous Programming Guides](https://awesome-repositories.com/f/education-learning-resources/educational-resources/languages-and-programming-concepts/programming-language-mastery-guides/asynchronous-programming-guides.md) — Provides a comprehensive guide to mastering non-blocking execution via polling state machines and futures. ([source](https://microsoft.github.io/RustTraining/async-book/))
- [Language Fundamentals](https://awesome-repositories.com/f/education-learning-resources/educational-resources/languages-and-programming-concepts/software-engineering-languages/language-fundamentals.md) — Covers essential language fundamentals including variables, primitive types, control flow, and function signatures. ([source](https://microsoft.github.io/RustTraining/python-book/))
- [Error Handling Patterns](https://awesome-repositories.com/f/education-learning-resources/error-handling-patterns.md) — Teaches robust error management strategies using specialized types to prevent runtime crashes. ([source](https://microsoft.github.io/RustTraining/c-cpp-book/))
- [Language Transition Guides](https://awesome-repositories.com/f/education-learning-resources/language-transition-guides.md) — Provides a specialized framework for mapping concepts from C++, managed languages, and dynamic typing to idiomatic Rust.
- [Managed Language Transitioning](https://awesome-repositories.com/f/education-learning-resources/managed-language-transitioning.md) — Bridges the gap between garbage-collected languages and Rust's ownership model for developers from managed ecosystems. ([source](https://microsoft.github.io/RustTraining/))
- [Programming Courses](https://awesome-repositories.com/f/education-learning-resources/programming-courses.md) — Delivers a structured course on systems programming, focusing on memory safety and low-level hardware interaction.
- [System Programming Concepts](https://awesome-repositories.com/f/education-learning-resources/system-programming-concepts.md) — Provides educational explanations of low-level system concepts like memory ownership and borrowing.
- [Systems Programming Training](https://awesome-repositories.com/f/education-learning-resources/systems-programming-training.md) — Delivers professional training on low-level systems programming, including unsafe code and zero-copy serialization. ([source](https://microsoft.github.io/RustTraining/rust-patterns-book/))
- [High-Performance Systems Patterns](https://awesome-repositories.com/f/education-learning-resources/advanced-programming-references/high-performance-systems-patterns.md) — Teaches the implementation of high-performance patterns using pins, custom allocators, and lock-free structures. ([source](https://microsoft.github.io/RustTraining/))
- [Architectural Pattern Translation](https://awesome-repositories.com/f/education-learning-resources/architecture-patterns/architectural-pattern-translation.md) — Instructs on converting common architectural patterns, such as interfaces and classes, into Rust traits and structs. ([source](https://microsoft.github.io/RustTraining/csharp-book/))
- [Asynchronous Project Tutorials](https://awesome-repositories.com/f/education-learning-resources/asynchronous-project-tutorials.md) — Provides practical projects for applying asynchronous concurrency concepts to real-world applications. ([source](https://microsoft.github.io/RustTraining/async-book/))
- [Language Idiom Comparisons](https://awesome-repositories.com/f/education-learning-resources/comparative-analyses/language-idiom-comparisons.md) — Teaches core fundamentals by comparing Rust idioms to equivalent concepts in other language ecosystems. ([source](https://microsoft.github.io/RustTraining/csharp-book/))
- [Type-Safe Data Modeling](https://awesome-repositories.com/f/education-learning-resources/data-structure-implementations/type-safe-data-modeling.md) — Teaches the use of structs and enums to create robust, type-safe data models with exhaustive pattern matching. ([source](https://microsoft.github.io/RustTraining/python-book/))
- [Dynamic to Static Typing Transitions](https://awesome-repositories.com/f/education-learning-resources/dynamic-to-static-typing-transitions.md) — Guides Python developers in transitioning from dynamic typing to static typing and implementing GIL-free concurrency. ([source](https://microsoft.github.io/RustTraining/))
- [Interactive Programming Playgrounds](https://awesome-repositories.com/f/education-learning-resources/interactive-programming-playgrounds.md) — Utilizes editable code playgrounds, conceptual diagrams, and practical exercises to reinforce technical learning. ([source](https://github.com/microsoft/rusttraining#readme))
- [Practical Application Exercises](https://awesome-repositories.com/f/education-learning-resources/practical-application-exercises.md) — Provides guided projects to practice data modeling and business logic through functional application development. ([source](https://microsoft.github.io/RustTraining/python-book/))
- [Software Architecture Curricula](https://awesome-repositories.com/f/education-learning-resources/software-architecture-curricula.md) — Provides a structured curriculum for designing ergonomic APIs and organizing professional software packages. ([source](https://microsoft.github.io/RustTraining/rust-patterns-book/))

### Programming Languages & Runtimes

- [Rust Tutorials](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/language-specific-resources/language-tutorials/rust-tutorials.md) — Offers structured curricula and practical exercises for mastering core Rust syntax and idioms.
- [C++ to Rust Transitioning](https://awesome-repositories.com/f/programming-languages-runtimes/c-library-embedding/standard-library-mappings/rust-c-mappings/c-to-rust-transitioning.md) — Helps C++ developers translate memory management and foreign function interface concepts into idiomatic Rust. ([source](https://microsoft.github.io/RustTraining/))
- [Generic Types](https://awesome-repositories.com/f/programming-languages-runtimes/generic-types.md) — Instructs on using traits and generics to implement reusable, type-safe code and design patterns. ([source](https://microsoft.github.io/RustTraining/c-cpp-book/))
- [Generics](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/core-conceptual-frameworks/programming-language-concepts/generics.md) — Teaches the application of parametric polymorphism using generics and trait bounds. ([source](https://microsoft.github.io/RustTraining/python-book/))
- [Language Transition Mapping](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/language-transition-mapping.md) — Features a framework that maps concepts from C++, managed languages, and dynamic typing to idiomatic Rust. ([source](https://microsoft.github.io/RustTraining/c-cpp-book/))
- [Metaprogramming Frameworks](https://awesome-repositories.com/f/programming-languages-runtimes/metaprogramming-frameworks.md) — Provides instruction on creating declarative and procedural macros to reduce boilerplate and extend language functionality. ([source](https://microsoft.github.io/RustTraining/c-cpp-book/))
- [Rust](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/systems-languages/rust.md) — Provides a comprehensive structured training curriculum for the Rust programming language from beginner to expert levels.
- [Trait-Based Polymorphism](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/type-systems/trait-based-polymorphism.md) — Instructs on using traits to implement polymorphism and generic constraints.
- [Asynchronous Programming](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtimes/asynchronous-execution-engines/asynchronous-programming.md) — Provides comprehensive training on non-blocking execution using futures, async/await, and runtime executors.
- [Rust Metaprogramming](https://awesome-repositories.com/f/programming-languages-runtimes/rust-metaprogramming.md) — Covers advanced use of declarative and procedural macros to automate code generation and reduce boilerplate.
- [Production Async Implementation](https://awesome-repositories.com/f/programming-languages-runtimes/asynchronous-streams/production-async-implementation.md) — Teaches the implementation of futures, streams, and cancellation safety for production-ready asynchronous applications. ([source](https://microsoft.github.io/RustTraining/))
- [Binary Size Optimizations](https://awesome-repositories.com/f/programming-languages-runtimes/binary-size-optimizations.md) — Provides guidance on reducing executable footprints via release profiles and dependency pruning. ([source](https://microsoft.github.io/RustTraining/engineering-book/))
- [Concurrency Patterns](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/core-conceptual-frameworks/programming-language-concepts/concurrency-patterns.md) — Teaches thread-safe application development using message passing, shared state, and async runtimes. ([source](https://microsoft.github.io/RustTraining/rust-patterns-book/))
- [Metaprogramming & Macros](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/metaprogramming-macros.md) — Teaches the use of declarative and procedural macros for compile-time code generation.
- [Foreign Function Interfaces](https://awesome-repositories.com/f/programming-languages-runtimes/language-interoperability/foreign-function-interfaces.md) — Provides instruction on integrating external libraries and other languages using foreign function interfaces.
- [External Library Integrations](https://awesome-repositories.com/f/programming-languages-runtimes/language-interoperability/native-c-interoperability/external-library-integrations.md) — Covers the use of foreign function interfaces and unsafe blocks to integrate and wrap external C and C++ libraries. ([source](https://microsoft.github.io/RustTraining/c-cpp-book/))
- [Module and Package Management](https://awesome-repositories.com/f/programming-languages-runtimes/module-and-package-management.md) — Teaches how to use package managers and registries to organize code into modules and workspaces. ([source](https://microsoft.github.io/RustTraining/c-cpp-book/))
- [Engineering Tutorials](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/language-specific-resources/language-tutorials/rust-tutorials/engineering-tutorials.md) — Provides practical guides for build scripts, cross-compilation, and professional delivery pipelines.
- [Type-State Patterns](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/type-systems/typed-state-management/type-safe-state-architectures/type-state-patterns.md) — Provides guidance on enforcing program state correctness at compile time using the type-state pattern.
- [Cross-Platform Binary Generation](https://awesome-repositories.com/f/programming-languages-runtimes/source-code-compilers/multi-target-compilers/cross-platform-binary-generation.md) — Teaches how to generate executable binaries for diverse hardware architectures and operating systems. ([source](https://microsoft.github.io/RustTraining/engineering-book/))
- [Memory and Concurrency Error Detection](https://awesome-repositories.com/f/programming-languages-runtimes/undefined-behavior-detection/memory-and-concurrency-error-detection.md) — Teaches the use of sanitizers and fuzzing tools to detect undefined behavior, memory leaks, and race conditions. ([source](https://microsoft.github.io/RustTraining/engineering-book/))

### Part of an Awesome List

- [Language Transition Modules](https://awesome-repositories.com/f/awesome-lists/devtools/framework-support/language-transition-modules.md) — Implements a transition framework mapping C++, managed, and dynamic languages to Rust idioms.
- [CLI Applications](https://awesome-repositories.com/f/awesome-lists/devtools/cli-applications.md) — Guides the development of functional command-line applications as a practical learning project. ([source](https://microsoft.github.io/RustTraining/csharp-book/))
- [Concurrency and Parallelism](https://awesome-repositories.com/f/awesome-lists/devtools/concurrency-and-parallelism.md) — Instructs on achieving parallelism and thread safety using Rust's concurrency primitives. ([source](https://microsoft.github.io/RustTraining/python-book/))

### Operating Systems & Systems Programming

- [Concurrency Primitives](https://awesome-repositories.com/f/operating-systems-systems-programming/concurrency-primitives.md) — Teaches how to use synchronization traits to build multi-threaded applications that prevent data races. ([source](https://microsoft.github.io/RustTraining/c-cpp-book/))
- [Ownership-Based Memory Management](https://awesome-repositories.com/f/operating-systems-systems-programming/manual-memory-management/ownership-based-memory-management.md) — Covers the fundamental Rust memory model based on ownership and borrowing.
- [Bare Metal Development](https://awesome-repositories.com/f/operating-systems-systems-programming/systems-programming/bare-metal-development.md) — Provides training on writing code for embedded systems and kernels in restricted environments without a standard library. ([source](https://microsoft.github.io/RustTraining/c-cpp-book/))

### Software Engineering & Architecture

- [Domain-Driven Type Constraints](https://awesome-repositories.com/f/software-engineering-architecture/data-schema-validation/data-type-validation/domain-driven-type-constraints.md) — Instructs on using type system constraints to make invalid program states unrepresentable at compile time. ([source](https://microsoft.github.io/RustTraining/type-driven-correctness-book/))
- [Type-State Patterns](https://awesome-repositories.com/f/software-engineering-architecture/type-level-conditional-logic/type-state-patterns.md) — Teaches the use of generics, traits, and the type-state pattern to enforce program correctness at compile time. ([source](https://microsoft.github.io/RustTraining/rust-patterns-book/))
- [Async Event Loop Runtimes](https://awesome-repositories.com/f/software-engineering-architecture/async-event-loop-runtimes.md) — Provides a framework for evaluating and selecting asynchronous event loop runtimes. ([source](https://microsoft.github.io/RustTraining/async-book/))
- [Async Flow Patterns](https://awesome-repositories.com/f/software-engineering-architecture/asynchronous-task-managers/async-flow-patterns.md) — Instructs on building production-ready systems using asynchronous streams, backpressure, and graceful shutdowns. ([source](https://microsoft.github.io/RustTraining/async-book/))
- [Rust Delivery Pipelines](https://awesome-repositories.com/f/software-engineering-architecture/coding-best-practices/engineering-best-practices/rust-delivery-pipelines.md) — Provides guidance on setting up build scripts, cross-compilation pipelines, and automated delivery workflows. ([source](https://microsoft.github.io/RustTraining/))
- [Exception-Equivalent Result Types](https://awesome-repositories.com/f/software-engineering-architecture/error-handling-strategies/monadic-error-handling/exception-equivalent-result-types.md) — Provides training on using Result and Option types as idiomatic alternatives to exception-based error handling. ([source](https://microsoft.github.io/RustTraining/python-book/))
- [Language Adoption Strategies](https://awesome-repositories.com/f/software-engineering-architecture/language-adoption-strategies.md) — Provides strategies and translation patterns for incrementally migrating codebases from Python to Rust. ([source](https://microsoft.github.io/RustTraining/python-book/))
- [Rust Engineering Workflows](https://awesome-repositories.com/f/software-engineering-architecture/rust-engineering-workflows.md) — Teaches professional engineering practices including build script configuration and automated delivery pipelines.
- [Asynchronous Execution State Machines](https://awesome-repositories.com/f/software-engineering-architecture/state-machine-logic/lightweight-state-machines/asynchronous-execution-state-machines.md) — Explains how asynchronous futures are implemented as polling state machines.
- [Zero-Overhead Abstractions](https://awesome-repositories.com/f/software-engineering-architecture/zero-overhead-abstractions.md) — Explains the design of high-level abstractions that incur no runtime performance penalty.

### Development Tools & Productivity

- [Build Scripts](https://awesome-repositories.com/f/development-tools-productivity/build-scripts.md) — Provides guidance on writing custom build scripts to manage dependencies and code generation. ([source](https://microsoft.github.io/RustTraining/engineering-book/))
- [Python Extension Development](https://awesome-repositories.com/f/development-tools-productivity/compilers-toolchains/c-extension-interfaces/c-extension-development/python-extension-development.md) — Teaches how to write high-performance native extensions for Python using Rust. ([source](https://microsoft.github.io/RustTraining/python-book/))

### DevOps & Infrastructure

- [Conditional Compilation](https://awesome-repositories.com/f/devops-infrastructure/cicd-pipeline-automation/core-build-engines/build-tooling/build-configuration-governance/platform-specific-source-resolution/conditional-compilation.md) — Teaches how to use conditional compilation to support multiple target platforms.

### Testing & Quality Assurance

- [Performance Measurement](https://awesome-repositories.com/f/testing-quality-assurance/performance-testing-analysis/performance-diagnostics/performance-measurement.md) — Instructs on measuring execution speed and generating flamegraphs to identify and resolve processing bottlenecks. ([source](https://microsoft.github.io/RustTraining/engineering-book/))