Bibliography and Sources

The writing on the material in this book is mostly scattered: official documentation, RFCs, blog posts by Rust team members, and a few books. Here are the sources this book drew on, organized roughly by chapter.

Official documentation

• The Rust Programming Language — doc.rust-lang.org/book. The prerequisite. If anything in this book felt like it skipped the basics, the basics are here.
• The Rust Reference — doc.rust-lang.org/reference. The formal description of the language. Dense, accurate, occasionally the only authoritative source for an obscure question.
• The Rustonomicon — doc.rust-lang.org/nomicon. Subtitle: The Dark Arts of Advanced and Unsafe Rust Programming. Mostly about unsafe code, but the chapters on subtyping, variance, and lifetimes are the canonical references for chapters 1 and 2 of this book.
• Asynchronous Programming in Rust — rust-lang.github.io/async-book. The official introduction to async. The chapter on the executor model and Pin is particularly good.

Posts by Rust team members and async working group

• Niko Matsakis (smallcultfollowing.com/babysteps) — the canonical source for type system internals. Posts on lifetime inference, HRTB, async traits, and the implementation of NLL (non-lexical lifetimes) are essential reading.
• Aaron Turon (aturon.github.io/blog) — laid the foundation for Rust’s async model in 2016. The posts on zero-cost futures, abstraction without overhead, and the design of trait objects are still relevant.
• Withoutboats (without.boats) — the design history of Pin, the early thinking on async, and several posts on what the language could have been. Disagrees with later async direction in places; worth reading regardless.
• Ralf Jung (ralfj.de/blog) — the formal model of Rust’s memory and aliasing. Stacked Borrows, Tree Borrows, and Miri all originate here. Essential if you write unsafe.
• Alice Ryhl (ryhl.io/blog) — practical async patterns. Actors with Tokio is the canonical reference for the actor pattern; Async: What is blocking? is the canonical reference for the blocking-vs-async distinction.
• The Rust async working group’s vision document — the roadmap for async Rust as of 2026.

Books

• Rust for Rustaceans by Jon Gjengset (No Starch Press, 2021). The closest thing to a prerequisite for this book in print form. Covers async, lifetimes, and unsafe at the level of someone who is past the basics but not yet at the limits.
• Programming Rust (2nd ed.) by Jim Blandy, Jason Orendorff, Leonora Tindall (O’Reilly, 2021). Comprehensive reference, treats lifetimes carefully, has a useful chapter on async.
• Zero To Production In Rust by Luca Palmieri (self-published, ongoing). Async Rust applied to a real production system. Worth reading for the patterns it shows by example.

Videos

• Jon Gjengset’s Crust of Rust series — long-form livecoding walking through advanced Rust topics. The episodes on async, Pin, and lifetimes are excellent supplements to the corresponding chapters here.
• The RustConf talks on async internals from various years. Search for “async” plus “Niko Matsakis” or “Tyler Mandry” or “Eric Holk.”

RFCs

The relevant RFCs for the material in this book:

• RFC 0066 — temporary lifetimes.
• RFC 1214 — projections, lifetimes, and well-formedness.
• RFC 2349 — Pin.
• RFC 2394 — async/await syntax.
• RFC 2592 — the Future trait in std.
• RFC 3185 — async fn in traits, the static-dispatch case.
• RFC 3425 — return-position impl Trait in traits.

Crates referenced

• tokio — the dominant async runtime.
• async-trait — boxed-future trait macro.
• trait-variant — generates boxed variants of native async traits.
• pin-project and pin-project-lite — safe Pin projection.
• bytemuck — safe transmutation.
• ouroboros — self-referential structs without writing unsafe.
• crossbeam — lock-free data structures.
• parking_lot — faster Mutex/RwLock than std.
• embassy — async runtime for embedded.

Where to go after this book

This book is a survival guide. To go deeper, in roughly this order:

1. Write more code in the patterns from chapter 9 until they are reflexive.
2. Read the source of tokio, particularly the task and sync modules. Surprisingly readable.
3. Read the source of pin-project to see what safe pin projection looks like in practice.
4. Read Niko’s blog backwards in time, starting from the most recent posts about async.
5. Pick a small unsafe-using crate (bytes, parking_lot, or crossbeam) and read its unsafe blocks; check the safety comments against your understanding.
6. Run Miri on your own code if you have any. Even if you don’t have unsafe, Miri will catch some categories of bugs in dependencies.

The material in this book gets internalized by use, not by reading. Write more code. Hit more walls. Each wall, eventually, becomes a door.