Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Where to Next

If you only remember one thing: you now know enough Rust to read almost any Rust code in the wild. The rest of this book is depth on top of the ideas you already have.

What you know now

Look at everything Part 0 just covered:

  • cargo new, cargo run, cargo build --release — the whole daily workflow
  • let, let mut, shadowing, and why Rust defaults to immutable
  • struct for “and”, enum for “or”, and the match that makes enums honest
  • Ownership: one owner, scope-bound drop, moves
  • Borrowing: &T (many readers) vs &mut T (one exclusive writer)
  • Option<T> for “might be absent” and Result<T, E> for “might have failed”
  • The ? operator for propagating errors idiomatically
  • A real CLI program, compiled to a native binary

That is roughly eighty percent of the Rust you will use in the first year on the job. The remaining twenty percent — iterators, traits, generics, async, smart pointers, concurrency, unsafe — are refinements and power features. You do not need them to be useful.

Proof, before you pick a path: step through this snippet. A week ago it was hieroglyphics; now you can narrate every line.

Interactive simulation (requires JavaScript): a capstone walkthrough of a struct with an owned String field, a borrowed view of it, and an exhaustive match — every concept from Part 0 in one short program.

## Pick your path
Three routes
  1. Slow and thorough. Continue straight into Part 1 and read the book in order. Parts 1 and 2 re-teach everything in Part 0 with the details Part 0 skipped. This is the path if you want to really own the language.
  2. Ownership deep-dive. Jump to Part 3 — The Heart of Rust. If "ownership in one page" left you wanting the full picture with lifetimes, moves, and the borrow checker's reasoning, this is the part for you.
  3. I want to build things now. Pick a small real problem and build it. The best next projects for Part 0 graduates are: a CLI that processes a log file, a small HTTP server with axum, a tokio-based async task, or a tiny game with bevy. Use Appendix D to pick a crate.

The reference card

Bookmark these pages. You will come back to them:

A note on the rest of the book

The tone changes a little after Part 0. The book is a real handbook — when we introduce lifetimes or Pin or unsafe, we give you the full machinery, not a simplification. The analogies and pictures stay, but the chapters get longer and the material gets denser, because the material itself is denser. That is fine. You are ready for it now.

A note from the author

Straight talk

Rust's reputation as "hard" comes from one thing: most books teach the syntax and assume you will figure out the mental model. You don't. You absorb it.

This book tries to flip that. Part 0 was the mental model first. The syntax was just the notation we used to write down what we already understood. If you felt like "oh, that was fine" — that's the feeling we were aiming for. It wasn't luck. It was the order of teaching.

Go build something.

Continue to Part 1 — Why Rust Exists →