Resources
The rest of this book assumes you are comfortable with Rust as a language. If you are still learning, or want to deepen your understanding of specific areas like async or atomics, the resources below are a good place to start.
Books
The Rust Programming Language, 2nd Edition by Steve Klabnik and Carol Nichols
The official book of the Rust programming language. Covers the language and toolchain from the ground up, with example projects that show how concepts fit together in practice. The starting point for most Rust developers. Also available in print.
Effective Rust by David Drysdale
Hands-on recommendations for writing idiomatic Rust code, organized as a series of actionable items covering types, traits, error handling, dependencies, and tooling. Particularly strong on the “why” behind Rust idioms. Also available in print.
Rust for Rustaceans by Jon Gjengset
A deep dive for developers who already know the basics. Covers designing interfaces, writing effective tests, unsafe code, async internals, and performance. Contains one of the clearest explanations of how async works under the hood.
Rust Atomics and Locks by Mara Bos
Covers low-level concurrency: atomics, memory ordering, and lock implementations. Essential reading if you need to implement custom synchronization primitives or understand why certain concurrent patterns are safe in Rust and others are not.
Rust Design Patterns (archived) by Rust Community
A community-maintained catalogue of design patterns, anti-patterns, and idioms specific to Rust. Each entry includes rationale explaining why a pattern works well or why an anti-pattern should be avoided.
The Rustonomicon by The Rust Project
The official guide to unsafe Rust. Covers raw pointers, transmutes, uninitialized memory, the Drop Check, and the exact rules for what constitutes undefined behavior. Essential reading if you work with FFI (see the Interop chapter) or need to implement data structures that require unsafe code.
Rust by Example by The Rust Community
A companion to The Rust Programming Language that teaches through annotated, runnable examples rather than long explanations. Each concept is demonstrated with code you can modify and run in the browser. A good option if you prefer learning by doing.
The Cargo Book by The Rust Project
The official reference for Cargo: dependency management, workspace configuration, build scripts, feature flags, publishing, and custom profiles. Since nearly every chapter in this book involves Cargo in some way, this is a useful reference to keep at hand.
For more Rust books, see The Little Book of Rust Books and The Rust Bookshelf.
Courses
Comprehensive Rust by Google
A multi-day Rust training course developed by Google’s Android team. Covers the language from basics through advanced topics like async and unsafe, with exercises throughout. A good option if you prefer structured, classroom-style learning.
Zero to Production in Rust by Luca Palmieri
A practical guide that walks through building a production-ready web application in Rust, covering project setup, database migrations, logging, error reporting, and deployment. Good for seeing how the tools and practices discussed in this book come together in a real project.
Articles
These articles cover similar ground to this book, approaching Rust project practices from different angles. Reading them alongside this book gives you a broader perspective on where the Rust community has converged and where opinions still differ.
One Hundred Thousand Lines of Rust by Alex Kladov
Lessons from maintaining several mid-sized Rust projects, including rust-analyzer. Covers documentation, testing strategies, build times, and project organization. Many of the recommendations align with what this book covers, but from the perspective of someone maintaining widely-used developer tools.
Basic Things by Alex Kladov
Argues that foundational infrastructure (documentation, code review, testing, reproducible builds, metrics) compounds over time and becomes a major multiplier as projects grow. A good companion to the Checks and Testing chapters of this book.
My Ideal Rust Workflow by Amos Wenger
A detailed walkthrough of one developer’s professional Rust setup, covering editor configuration, automated checks with Clippy and cargo-hack, CI pipelines, and private infrastructure. Useful for seeing how the individual tools discussed in this book fit together in a cohesive workflow.
Good Practices for Writing Rust Libraries by Pascal Hertleif
A practical checklist for publishing Rust libraries: code quality tools (rustfmt, Clippy, lints), project metadata, README conventions, CI setup, and documentation deployment. Written in 2015 but most of the advice remains relevant.
Describes the testing strategy for Sciagraph, a Python memory profiler built with Rust. Covers coverage marks (verifying specific code paths are hit), property-based testing with proptest, end-to-end tests in both debug and release modes, and panic injection testing. Also discusses choosing Rust for memory safety, wrapping unsafe APIs in safe interfaces, and environmental assertions at startup to catch configuration mismatches.
Videos
Setting up CI and Property Testing for a Rust Crate by Jon Gjengset
Jon walks through setting up a CI pipeline and property testing for one of his crates, explaining his reasoning at each step. A good complement to the Testing and CI chapters of this book, as it shows the process of making these decisions in real time.