Skip to content
PracticalHandbooksSoftware Handbooks
Library

Practical handbook

The Rust Engineering Handbook

A production-minded reference for reasoning about Rust's ownership, type, concurrency, API, unsafe, compatibility, and operational contracts.

Start Reading All books
A precision-forged systems bridge whose interlocking paths represent ownership, borrowing, types, concurrency, and safe boundaries.

Reading order

Contents

Part 1

Rust as an Engineering System

5 entries
  1. 01 A Complete Rust Program, Read as a Senior Engineer
  2. 02 Rust's Contract: Safety, Control, and Cost
  3. 03 Toolchains, Editions, Channels, and Stability
  4. 04 Expressions, Statements, Places, Values, and Evaluation
  5. 05 The Compiler as a Design Partner

Part 2

Part II — Ownership, Borrowing, and Destruction

7 entries
  1. 06 Moves, Copies, Clones, and Partial Moves
  2. 07 Shared and Mutable Borrowing
  3. 08 Lifetimes as Relationships
  4. 09 Reborrowing, Non-Lexical Lifetimes, Two-Phase Borrows, and Higher-Ranked Bounds
  5. 10 Interior Mutability
  6. 11 RAII, Drop, Destruction Order, Leaks, and Cycles
  7. 12 Ownership-Driven Refactoring and Architecture

Part 3

Part III — Algebraic Data and Pattern-Directed Design

5 entries
  1. 13 Structs, Enums, and Invariant-Rich Domain Models
  2. 14 Pattern Matching and Exhaustiveness
  3. 15 Option, Result, Divergence, and Control-Flow Composition
  4. 16 State Machines, Typestate, and Protocols
  5. 17 Numeric Semantics, Overflow, and Bit-Level Correctness

Part 4

Part IV — Generics, Traits, and Abstraction

8 entries
  1. 18 Generics, Bounds, and Monomorphization
  2. 19 Traits and Associated Items
  3. 20 Coherence, Orphan Rules, and Extension Patterns
  4. 21 Static Dispatch, Dynamic Dispatch, and dyn Compatibility
  5. 22 Closures and the Fn Trait Family
  6. 23 Iterator Architecture and Lazy Pipelines
  7. 24 Conversion, Borrowing, Dereference, and View Traits
  8. 25 Advanced Type Patterns

Part 5

Data memory and representation

8 entries
  1. 26 Layout, Alignment, Niches, and Representation
  2. 27 Pointers and Smart Pointers
  3. 28 Slices, Strings, Bytes, and UTF-8
  4. 29 Collections and Ownership-Aware Data Structures
  5. 30 Dynamically Sized Types, Fat Pointers, Unsizing, and Trait Objects
  6. 31 Pinning and Self-Referential Constraints
  7. 32 Allocation Strategies, Arenas, Pools, and Allocation-Free Paths
  8. 33 Zero-Copy Parsing and Borrowed Data Models

Part 6

Errors panics and robustness contracts

4 entries
  1. 34 Error Taxonomy and Result Design
  2. 35 Error Context, Conversion, and Reporting
  3. 36 Panics, Unwinding, Abort, and Exception Safety
  4. 37 Cancellation, Idempotency, and Cleanup Contracts

Part 7

Cargo crates and system architecture

7 entries
  1. 38 Packages, Crates, Modules, Visibility, and the Prelude
  2. 39 Workspaces and Multi-Crate Architecture
  3. 40 Manifests, Dependency Resolution, and Lockfiles
  4. 41 Features, Conditional Compilation, Targets, and Portability
  5. 42 Build Scripts, Native Dependencies, and Generated Code
  6. 43 Profiles, Linkers, Cross-Compilation, and Reproducible Builds
  7. 44 Editions, MSRV, SemVer, and Release Engineering

Part 8

Public API and library design

7 entries
  1. 45 Ownership Choices in Function and Type Signatures
  2. 46 Designing Public Types and Traits for Evolution
  3. 47 Builders, Configuration, and Typestate APIs
  4. 48 Generic, Concrete, and Dynamic Boundaries
  5. 49 Error, Cancellation, and Async Contracts in Public APIs
  6. 50 Rustdoc, Examples, Discoverability, and Feature Documentation
  7. 51 API Review and Compatibility Case Study

Part 9

Threads synchronization and parallelism

6 entries
  1. 52 Send, Sync, and Thread-Safety Boundaries
  2. 53 Threads, Scoped Threads, and Work Decomposition
  3. 54 Channels and Ownership Transfer
  4. 55 Shared State: Mutexes, Read-Write Locks, Condition Variables, and One-Time Initialization
  5. 56 Atomics and the Memory Model
  6. 57 Contention, Deadlocks, Lock-Free Structures, and Data Parallelism

Part 10

Async rust and networked systems

8 entries
  1. 58 Future, Poll, Waker, and the Generated State Machine
  2. 59 async/.await Borrowing, Lifetimes, Send, and Pinning
  3. 60 Executors, Reactors, Runtimes, and Runtime Boundaries
  4. 61 Tasks, Cancellation, Structured Concurrency, and Shutdown
  5. 62 Streams, Backpressure, Buffering, and Fairness
  6. 63 Timeouts, Retries, Racing, and Idempotent I/O
  7. 64 Async Traits, Service Abstractions, and Testing
  8. 65 Production Async Service Case Study

Part 11

Unsafe rust and foreign boundaries

9 entries
  1. 66 The Unsafe Contract and Safety-Case Method
  2. 67 Validity, Initialization, MaybeUninit, and ManuallyDrop
  3. 68 Raw Pointers, Provenance, Aliasing, and References
  4. 69 Building Safe Abstractions Around Unsafe Internals
  5. 70 Representation, Unions, Bit Operations, and Transmutation
  6. 71 Unsafe Traits, Send/Sync, Drop Safety, and Panic Safety
  7. 72 C ABI and FFI: Ownership, Errors, Callbacks, and Unwinding
  8. 73 Cross-Language Bindings and Boundary Architecture
  9. 74 Miri, Sanitizers, Fuzzing, and Unsafe Audits

Part 12

Macros and compile time engineering

4 entries
  1. 75 Declarative Macros: Syntax, Hygiene, and Recursion
  2. 76 Procedural Macros: Token Streams, Spans, and Diagnostics
  3. 77 Derive, Attribute, and Function-Like Macro API Design
  4. 78 Const Evaluation, Build-Time Generation, and Metaprogramming Trade-offs

Part 13

Testing verification and quality gates

5 entries
  1. 79 Test Architecture: Unit, Integration, Documentation, and UI Tests
  2. 80 Property-Based, Model-Based, Snapshot, and Golden Testing
  3. 81 Fuzzing, Sanitizers, Miri, and Concurrency Exploration
  4. 82 CI Matrices, Lints, Feature Combinations, and MSRV
  5. 83 Designing for Testability and Hermeticity

Part 14

Performance operations and security

10 entries
  1. 84 Measurement and Benchmark Design
  2. 85 Rust’s Cost Model: Allocation, Copies, Dispatch, Syscalls, and Caches
  3. 86 Compiler Optimization, Inlining, LTO, PGO, and Code Size
  4. 87 Profiling CPU, Memory, I/O, Locks, and Async Tasks
  5. 88 Observability: Structured Events, Metrics, Errors, and Backtraces
  6. 89 Production I/O, Configuration, Secrets, Shutdown, and Deployment
  7. 90 Resilience Under Load: Admission Control, Backpressure, and Degradation
  8. 91 Security Engineering: Memory Safety Is Not a Threat Model
  9. 92 Dependency Governance, SBOMs, Advisories, and Reproducible Supply Chains
  10. 93 Production Readiness and Performance Case Study

Part 15

Platforms adoption and technical leadership

6 entries
  1. 94 no_std, alloc, Embedded Systems, and Firmware
  2. 95 WebAssembly, Kernels, Drivers, and Constrained Runtimes
  3. 96 Application Archetypes: CLI, Library, Service, Data Plane, and Compute
  4. 97 Migration from C, C++, Go, Java, and Existing Systems
  5. 98 Team Standards, Code Review, Mentoring, and Unsafe Governance
  6. 99 Long-Term Maintenance: Editions, MSRV, Incidents, and Ecosystem Change

Reference section

Appendices

20 entries
  1. Appendix A Appendix A — Rust Syntax and Reading Reference
  2. Appendix B Appendix B — Ownership and Borrowing Decision Tables
  3. Appendix C Appendix C — Lifetime Pattern Catalog
  4. Appendix D Appendix D — Trait and Dispatch Reference
  5. Appendix E Appendix E — Conversion and View Trait Matrix
  6. Appendix F Appendix F — Standard-Library Type Selection Guide
  7. Appendix G Appendix G — Numeric and Bitwise Correctness Checklist
  8. Appendix H Appendix H — Error and Panic Design Checklist
  9. Appendix I Appendix I — Cargo and Workspace Reference
  10. Appendix J Appendix J — Public API Review Checklist
  11. Appendix K Appendix K — Unsafe Code Review Checklist
  12. Appendix L Appendix L — FFI Boundary Checklist
  13. Appendix M Appendix M — Concurrency and Async Review Checklist
  14. Appendix N Appendix N — Memory-Ordering Litmus Reference
  15. Appendix O Appendix O — Performance Experiment Template
  16. Appendix P Appendix P — Security and Supply-Chain Checklist
  17. Appendix Q Appendix Q — Edition, MSRV, SemVer, and Release Policy Templates
  18. Appendix R Appendix R — Code Review Checklist
  19. Appendix S Appendix S — Glossary and Terminology Cross-Reference
  20. Appendix T Appendix T — Source Map and Further Reading