Rust — The Complete Field Guide (Beginner → Expert)

Contents

79 chapters, one page each. Prefer one long page? Read the whole book on one page.

1. How to use this guide2 min
2. Table of contents3 min
3. Part 0 — Start here
4. 0.1 Setup: rustup, cargo, rust-analyzer, clippy1 min
5. 0.2 The series: OS → networking → security → HTTPS → Go → C → Rust3 min
6. 0.3 The Go ↔ C ↔ Rust phrasebook2 min
7. 0.4 The Rust labs: what you build for each guide in the series2 min
8. Part I — Foundations: the Rust way
9. 1. What Rust is, and why it exists3 min
10. 2. The toolchain: cargo, crates, editions, and what cargo build really does2 min
11. 3. Variables, mutability, shadowing, and scalar types3 min
12. 4. Control flow: everything is an expression2 min
13. 5. Functions, statements, and the unit and never types1 min
14. 6. Ownership: moves, copies, and drop4 min
15. 7. Borrowing: shared XOR mutable3 min
16. 8. Slices and strings: fat pointers and UTF-82 min
17. 9. Structs, enums, and pattern matching3 min
18. 10. Error handling: Result , ? , and panics3 min
19. 11. Collections: Vec , HashMap , and friends1 min
20. 12. Modules, crates, and visibility1 min
21. 13. 🔎 Checkpoint: ownership and borrowing2 min
22. 14. Terminal project: a word-frequency counter1 min
23. 15. Terminal project: a /etc/hosts -style config parser with real errors2 min
24. Part II — Intermediate: traits, lifetimes, and the standard library
25. 16. Traits and generics: shared behavior without inheritance3 min
26. 17. Trait objects: dyn Trait and dynamic dispatch2 min
27. 18. The standard traits you will implement every week2 min
28. 19. Lifetimes: naming how long a borrow is valid3 min
29. 20. Closures: Fn , FnMut , FnOnce1 min
30. 21. Iterators: lazy, composable, zero-cost2 min
31. 22. Smart pointers: Box , Rc , Arc , Cell , RefCell , Weak2 min
32. 23. Testing: unit, integration, doc tests, and property tests2 min
33. 24. I/O, files, processes, and application errors2 min
34. 25. 🔎 Checkpoint: traits and lifetimes1 min
35. 26. Terminal project: rgrep , a tested grep clone2 min
36. 27. Terminal project: an LRU cache, and why linked lists are hard in Rust3 min
37. Part III — Advanced: concurrency, async, unsafe
38. 28. Threads, and why data races do not compile3 min
39. 29. Shared state: Mutex , RwLock , atomics, Condvar , channels3 min
40. 30. Async Rust: futures, poll , and why async exists2 min
41. 31. Tokio in practice: tasks, select! , timeouts, cancellation, shutdown3 min
42. 32. Networking with std and Tokio: TCP, UDP, and framing3 min
43. 33. unsafe Rust: the five superpowers and the contract they carry2 min
44. 34. FFI: calling C from Rust and Rust from C2 min
45. 35. Macros: macro_rules! and what derive macros do1 min
46. 36. Performance: release profiles, benchmarks, profiling, allocations2 min
47. 37. Project: a thread pool from scratch2 min
48. 38. Project: a multi-room chat server with Tokio2 min
49. Part IV — Systems Rust: the OS guide in Rust
50. 39. Syscalls from Rust: std , libc , and nix2 min
51. 40. Processes, exit codes, and signals3 min
52. 41. Files that survive crashes: fsync and atomic replacement1 min
53. 42. Reading /proc : build your own ps1 min
54. 43. Memory: mmap and a counting global allocator2 min
55. 44. A container in 100 lines: namespaces with nix4 min
56. Part V — Network and HTTP services: the networking and HTTPS guides in Rust
57. 45. A DNS client from raw bytes5 min
58. 46. HTTP/1.1 from a bare TcpListener5 min
59. 47. A production HTTP server with Axum: limits, timeouts, tracing, shutdown3 min
60. 48. Outbound requests: timeouts, retries, idempotency, and an SSRF guard5 min
61. 49. TLS and mutual TLS with rustls3 min
62. 50. A reverse proxy with Hyper, and request-smuggling defenses4 min
63. Part VI — Security-focused Rust
64. 51. What Rust prevents, and what it does not2 min
65. 52. Cryptography done right: AEAD, password hashing, HMAC, constant-time, zeroize4 min
66. 53. Parsing untrusted input: newtypes, "parse, don't validate", resource bounds2 min
67. 54. Fuzzing and property testing2 min
68. 55. Supply chain: Cargo.lock , cargo audit , cargo deny , build.rs2 min
69. 56. Project: an auth service with Argon2 and JWTs4 min
70. Part VII — Expert: internals and design
71. 57. Memory layout: size, alignment, niches, repr(C) , fat pointers2 min
72. 58. Inside Vec , String , Box , and trait objects3 min
73. 59. How async compiles: state machines, Pin , and a tiny executor3 min
74. 60. Variance, PhantomData , and drop check2 min
75. 61. Memory ordering: Relaxed , Acquire / Release , SeqCst , and a spinlock3 min
76. 62. API design: newtypes, typestate, builders, errors, and semver3 min
77. 63. Capstone: a Redis-compatible key-value server with persistence6 min
78. 64. Capstone: one HTTPS request, every layer, every guide, in Rust4 min
79. Part VIII — Professional Rust
80. 65. Debugging: backtraces, lldb / gdb , tokio-console , Miri2 min
81. 66. Workspaces, CI quality gates, release builds, and cross-compilation2 min
82. 67. Running Rust in containers and Kubernetes2 min
83. 68. How not to write Rust: an anti-pattern catalog3 min
84. Appendices
85. Appendix A — Compiler-error decoder: the 15 errors you will actually see1 min
86. Appendix B — Cargo and tooling cheat sheet1 min
87. Appendix C — Glossary1 min
88. Appendix D — A 90-day plan1 min
89. Appendix E — Further reading and codebases worth reading1 min