Articles & Resources #
Rust has an outstanding documentation ecosystem — the community cares deeply about documentation quality and almost all primary sources are available for free. This page curates the best recommended resources, grouped by learning goal. Whether you’re just starting out, looking for a specific reference, or want to follow the Rust ecosystem’s developments — everything is here.
Official Books and Primary Guides #
The Rust Programming Language (“The Book”) #
The official Rust book written by the Rust team. This is the best starting point for everyone new to Rust.
https://doc.rust-lang.org/book/
Available free online and as a printed book (No Starch Press). Covers all core concepts: ownership, borrowing, lifetimes, traits, generics, error handling, and much more. Every chapter comes with a small project you can practice immediately.
Rust by Example #
Learn Rust through code examples you can run directly in the browser — no local installation needed.
https://doc.rust-lang.org/rust-by-example/
A different approach from The Book: more concise, more direct to code examples. Very useful as a quick reference or a complement to The Book.
The Rustonomicon #
The official guide to “unsafe” Rust — raw memory, FFI, and undefined behavior.
https://doc.rust-lang.org/nomicon/
Only for those already comfortable with Rust. Covers aspects the compiler can’t verify automatically.
Async Rust #
The official guide to asynchronous programming in Rust — futures, async/await, and runtimes.
https://rust-lang.github.io/async-book/
Required reading before using tokio, async-std, or any async framework.
The Cargo Book #
Complete documentation for Cargo — Rust’s package manager and build system.
https://doc.rust-lang.org/cargo/
Covers all Cargo features: workspaces, features, build scripts, custom profiles, and publishing to crates.io.
API References and Documentation #
Standard Library Reference #
https://doc.rust-lang.org/std/
Complete documentation of everything in the Rust standard library. Use the search (Ctrl+F or the search box) to find specific types, traits, or functions. Essential as a daily reference.
crates.io #
https://crates.io/
The official Rust crate registry. Search crates by name or category. Each crate shows download counts, versions, and links to documentation.
docs.rs #
https://docs.rs/
Automatic documentation for every crate published to crates.io. The URL is always consistent: https://docs.rs/crate-name. Documentation is generated from /// comments in the source code.
The Rust Reference #
https://doc.rust-lang.org/reference/
The detailed Rust language specification — for those who want to deeply understand language semantics. Not for beginners, but irreplaceable for questions like “is this behavior defined?”
Practice Platforms #
Rustlings #
Interactive exercises for learning Rust — fix broken code until all tests pass.
https://github.com/rust-lang/rustlings
Install with cargo install rustlings, then run rustlings watch. There are 90+ exercises covering all the main Rust topics.
Exercism — Rust Track #
https://exercism.org/tracks/rust
100+ exercises with human mentors giving feedback. Ideal for those who want feedback from experienced Rust programmers.
LeetCode with Rust #
Many algorithm problems on LeetCode can be solved in Rust. It’s an effective way to deepen your understanding of Rust data types and iterators while practicing algorithms.
Advent of Code #
https://adventofcode.com/
Daily programming challenges throughout December. Many Rust programmers use it for practice. You can try puzzles from previous years any time.
Specific Topics — Advanced Books #
Zero To Production In Rust #
https://www.zero2prod.com/
A paid book (highly recommended) that builds a real newsletter API from scratch using Actix-web, PostgreSQL, Redis, and full testing. This is the best reference for learning Rust in a production web development context.
Programming Rust (O’Reilly) #
https://www.oreilly.com/library/view/programming-rust-2nd/9781492052586/
A comprehensive book that goes deeper than The Book, with excellent explanations of concurrency and lifetimes. The second edition covers async Rust.
Rust for Rustaceans #
https://nostarch.com/rust-rustaceans
For Rust programmers who’ve mastered the basics and want to level up. Covers trait objects, unsafe, API design, testing, and other advanced topics.
Crafting Interpreters (with Rust) #
Although the original book uses Java/C, many Rust implementations are available on GitHub. A great project for learning ownership and lifetimes in a real context.
Videos and YouTube Channels #
Jon Gjengset (@jonhoo) #
https://www.youtube.com/@jonhoo
Long videos (2-8 hours) covering real implementations in Rust — from async/await internals, implementing HashMap from scratch, to productivity crates. Very high technical quality.
Let’s Get Rusty #
https://www.youtube.com/@letsgetrusty
Shorter, more structured Rust tutorials. The “Ultimate Rust Crash Course” series is great for beginners who prefer learning via video.
No Boilerplate #
https://www.youtube.com/@NoBoilerplate
Short videos (5-15 minutes) discussing why Rust excels in certain aspects. A unique and informative presentation style.
Rust Belt Rust / RustConf Talks #
https://www.youtube.com/@RustVideos
Presentations from official Rust conferences. Covers topics from beginner to very advanced — from “Rust for beginners” to “Implementing an async runtime from scratch”.
Newsletters and Blogs #
This Week in Rust #
https://this-week-in-rust.org/
A weekly newsletter summarizing Rust ecosystem developments: new articles, new crates, RFCs under discussion, and job openings. The best way to stay updated without monitoring many sources.
The Official Rust Blog #
https://blog.rust-lang.org/
Official announcements from the Rust team: new releases, feature stabilizations, and language development direction.
Inside Rust Blog #
https://blog.rust-lang.org/inside-rust/
A blog by the Rust developers themselves — more technical, discussing the language development process from the inside.
fasterthanli.me #
https://fasterthanli.me/
In-depth articles about Rust and systems programming in general. The author is known for very detailed and honest discussions of Rust’s complexity.
Tools and Development Environments #
VS Code Extension — rust-analyzer #
https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer
The official extension for VS Code. Provides: smart autocomplete, go-to-definition, inline compiler errors, rename refactoring, and much more. Essential for Rust development in VS Code.
IntelliJ Rust (JetBrains) #
https://www.jetbrains.com/rust/
A dedicated Rust IDE from JetBrains with full features including a visual debugger that’s better than VS Code’s.
Rustfmt #
rustup component add rustfmt
cargo fmt
The official Rust formatter. Configure via rustfmt.toml. Run before committing to keep code format consistent.
Clippy #
rustup component add clippy
cargo clippy
The official Rust linter with 600+ lint rules. Detects non-idiomatic code patterns, potential bugs, and code smells. Run as part of the CI pipeline.
cargo-watch #
cargo install cargo-watch
cargo watch -x run # restart when files change
cargo watch -x test # run tests when files change
Useful during development — automatically recompiles and reruns when files change.
cargo-expand #
cargo install cargo-expand
cargo expand # show code after macro expansion
Very useful for understanding in detail what proc-macros like #[derive(Serialize)] actually do.
cargo-audit #
cargo install cargo-audit
cargo audit # check dependency vulnerabilities
Scans dependencies against a database of known vulnerabilities. Important for production applications.
Communities #
The Rust Users Forum #
https://users.rust-lang.org/
The official Rust community forum for questions, discussions, and sharing projects. Very beginner-friendly with fast responses from experienced members.
Rust Discord #
https://discord.gg/rust-lang
The official Rust Discord server with per-topic channels: #beginners, #help, #async, #webdev, etc. The best place for questions needing quick answers.
Reddit r/rust #
https://www.reddit.com/r/rust/
The active Rust subreddit. Great for sharing articles, projects, and discussions about ecosystem developments.
Rust Internals Forum #
https://internals.rust-lang.org/
The forum for discussing the development of the Rust language itself — new RFCs, compiler changes, and design decisions.
Rust Learning Roadmap #
Here’s a recommended path based on experience and goals:
Beginner — Foundations (2–4 months) #
1. The Rust Book (chapters 1–15)
→ Ownership, borrowing, basic lifetimes
→ Struct, enum, trait
→ Error handling with Result
2. Rustlings
→ Practice all concepts from The Book
3. Rust by Example
→ Quick reference when you need a specific example
4. Build small projects:
→ CLI tool with clap
→ Simple file parser
→ Basic data structure implementations
Intermediate — Ecosystem (2–4 months) #
5. The Rust Book (chapters 16–20)
→ Concurrency, basic async
6. The Async Rust book
→ Futures, deep async/await
7. Build your first web project:
→ REST API with Axum or Actix-web
→ Database with sqlx
→ Testing with tokio::test
8. Exercism Rust Track
→ Feedback from mentors
Advanced — Mastery (ongoing) #
9. Rust for Rustaceans
→ Trait objects, unsafe, API design
10. Zero To Production In Rust
→ Production-grade web application
11. Jon Gjengset YouTube
→ Complex real-world implementations
12. Contribute to Rust open source:
→ Start with documentation or small bugs
→ crates.io, GitHub Rust projects
13. The Rustonomicon
→ Unsafe Rust, FFI, memory layout
Summary #
- Start with The Book — it’s the most comprehensive source with guaranteed quality. Read it from the beginning, don’t skip around.
- Practice with Rustlings — after each chapter of The Book, do the relevant Rustlings exercises to reinforce understanding.
- docs.rs for every crate — the
docs.rs/crate-nameURL is always available and always up-to-date with the latest version.- This Week in Rust — subscribe to this weekly newsletter to stay updated without feeling overwhelmed.
- The Rust community is very beginner-friendly — don’t hesitate to ask questions on the forum or Discord. “Dumb” questions are answered well and patiently in the Rust community.
- rust-analyzer is mandatory in VS Code — this isn’t optional; without it, writing Rust is much harder.
- cargo clippy and cargo fmt — make both a habit before every commit. Clippy often finds real bugs, not just style issues.
- Zero To Production In Rust is the best investment for Rust web developers — the paid book most worth the money in the Rust ecosystem.
- Patience is key — Rust has a steep learning curve, especially at the beginning. That’s normal. Once ownership “clicks”, many things that were confusing will suddenly make sense.