The best Rust books for 2025, reviewed
Rust is a popular, modern, memory-safe programming language originated by Graydon Hoare in 2006 and developed at Mozilla. Influenced by many important ideas from previous languages, Rust is focused on safety, correctness, and expressiveness, without sacrificing performance.
Its syntax is not radically different from other comparable languages such as Go, Java, or C++, but Rust’s “borrow checker” is often a challenge for new learners, because code has to be written in such a way that the compiler can verify that all memory references are valid. This means that Rust programmers need to have at least a basic understanding of computer memory, for example, including heap and stack allocation.
Many books are available that teach Rust programming at various levels. Let’s break down the top choices, as recommended by the Rust community, and look at the strengths and weaknesses of each title, including its intended audience.
The Rust Programming Language (“The Rust Book”)
The Rust Programming Language is the consensus recommendation in the Rust community for the first book every new programmer should read—it’s colloquially known as “the book”. It’s the official introduction to Rust, and available for free online.
The authors
Authors Steve Klabnik, Carol Nichols, and Chris Krycho, are well-known Rust experts and contributors. In addition, the book has received many contributions from the Rust community itself.
Readers say
Readers say it’s comprehensive, and explains fundamental concepts step by step. However, they also note that while The Rust Programming Language is a good reference work, it’s not necessary to read the entire book at first. Beginners are recommended to read the first few chapters to get an understanding of the basics, and save the more advanced material for later.
The first five or six chapters are enough to give learners a basic understanding of the language, and it’s recommended at that point that they try writing some Rust programs themselves, and perhaps move on to a more application-focused book such as The Secrets of Rust: Tools.
Compared to others
It’s more comprehensive than most books, though Programming Rust goes a little deeper on some topics such as the standard library. Unlike The Secrets of Rust: Tools, it doesn’t walk readers through developing realistic Rust projects, or present large chunks of working code like Zero to Production in Rust. However, it’s free, and widely regarded as the standard reference work.
The Secrets of Rust: Tools
The Secrets of Rust: Tools is a relatively new book, published in 2024, and designed as a companion to The Rust Programming Language. It focuses on teaching idiomatic Rust, best-practice design patterns, and test-driven development. Readers are guided through building a series of practical, useful tools in Rust, including a memo manager, a weather client, and a Cargo plugin.
The author
Author John Arundel is a respected Rust teacher and writer, with long and deep experience in the software industry and an impressive backlist of books on programming, including The Deeper Love of Go and Cloud Native DevOps with Kubernetes.
Readers say
Readers say The Secrets of Rust: Tools stands out from other Rust books for its beginner-friendly simplicity and focus on clean code. Others commented that the project-based style helps to show how Rust’s features come together into real programs. The clear, witty style met with approval from many, who found it more fun to read than some other books.
Compared to others
Unlike other more advanced books such as Rust for Rustaceans and Zero to Production in Rust, The Secrets of Rust: Tools assumes no previous knowledge of programming, making it ideal for someone learning Rust as a first language. It doesn’t attempt to rehash the material from The Rust Programming Language, focusing instead on how developers can apply their knowledge to solving practical problems.
Effective Rust
Effective Rust is a short, information-dense book on idiomatic Rust patterns and APIs. It’s not a beginner book, but targets more experienced programmers who want to fine-tune their knowledge of Rust and learn about where the different language features can most effectively be used.
The author
Author David Drysdale is a staff software engineer at Google, and has many years experience in Rust development.
Readers say
Readers say that the book is “packed with good advice”, and that it offers good jumping-off points for further learning. However, some criticised it as “shallow”, and noted that the book’s use of many examples of bad code could be confusing.
Compared to others
It’s not an introduction to the language, like The Rust Programming Language, or a guide to designing real-world software like The Secrets of Rust: Tools. Instead, Effective Rust focuses on the micro-details: specific method and syntax choices that optimise Rust programs to be idiomatic and efficient.
Rust for Rustaceans
Rust for Rustaceans was published in 2021, meaning that it’s not necessarily up to date with the latest features of Rust, but it’s still a well-respected book that dives deep into the technicalities of the language, and gives readers a thorough analytical grounding in topics like foreign function interfaces, procedural macros, and object.
The author
Jon Gjengset is a well-known figure in the Rust community for his educational videos and livestreams, and he’s also a frequent conference speaker.
Readers say
Rust for Rustaceans is often described as a good choice for intermediate Rust developers who are reasonably confident in their skills but want to deepen their knowledge. Readers appreciated the technical focus, but some found it “confusing” and hard to follow, saying that in their opinion the book was really for experts rather than intermediate developers.
Compared to others
Rust for Rustaceans isn’t as beginner-friendly or as clearly written as something like The Secrets of Rust: Tools, but it’s deeper and more analytical, covering topics like unsafe code, memory ordering, and covariant types. Like Effective Rust, it offers many tips on idiomatic Rust usages, though it doesn’t have such broad coverage of the standard library as Programming Rust.
Programming Rust
Programming Rust is a 2021 book which, like Rust for Rustaceans, is no longer current with modern Rust, but still contains much useful information. It’s especially notable for its comprehensive coverage of all Rust’s built-in types, standard library features, and lots of detailed code examples.
The authors
Jim Blandy is a software developer known for his work on the Firefox web browser and the Emacs editor. Leonora Tindall is a Rust engineer working in the healthcare field.
Readers say
Readers generally describe Programming Rust as “broad and deep”, praising its methodical approach to the nuts and bolts of Rust. Some noted it was not an easy read, but found the writing style relatively clear. Though there were a few complaints about typos and small mistakes, the consensus view is that Programming Rust is a solid work and, at over 700 pages, represents good value for money.
Compared to others
According to reviewers, there’s a fair amount of overlap between Programming Rust and similar books such as The Rust Programming Language and Rust for Rustaceans. While not the most up-to-date book, it has some unique material that’s still worth reading today. Unlike the more introductory works including The Secrets of Rust: Tools, it’s aimed at experienced programmers, especially those coming from a C++ background.
Rust in Action
Rust in Action aims to teach advanced Rust development through a number of technically-challenging projects, including CPU emulation, memory mapping, floating-point encoding, and raw network packet handling. It’s squarely pitched at those with a computer science and engineering background, rather than beginners, but would be suitable for those using Rust in the systems programming domain.
The author
Tim McNamara is a Rust consultant and YouTuber specialising in natural language processing and data engineering. Rust in Action is his first book.
Readers say
Readers described this book as “good for experienced C++ coders”, but warned that it’s “not for low-level language beginners”. Some found the heavily-annotated code samples confusing, but noted that the material was generally well explained.
Compared to others
Like many of the other titles on this list, Rust in Action is from 2021, so it’s not as up to date as more recent books like The Secrets of Rust: Tools. Unlike The Rust Programming Language or Programming Rust, it doesn’t attempt to be a complete guide to the language, instead focusing on important but niche topics such as systems programming and Windows. It’s strong on the technical detail of things like networking, but unlike Zero to Production in Rust, doesn’t cover popular topics such as web services.
Zero to Production in Rust
Zero to Production in Rust is a deliberately opinionated
guide to backend web development, aiming to present a complete,
realistic application and guide readers through understanding its
intricacies step by step. It’s a little more recent than some books on
this list, dating from 2022, though its chosen web framework
(actix-web) has nowadays been largely displaced by the more
modern and popular axum library.
The author
Luca Palmieri is a Rust developer and co-organiser of the Rust London User Group.
Readers say
Readers praised the book for its “clear, vivid explanations”, and appreciated its focus on a single web stack, rather than trying to help users choose between a bewildering variety of frameworks. However, some criticised the quality of the print book, citing “cheap, curly paper”, though they described the material itself as “comprehensive and well-structured”.
Compared to others
Zero to Production in Rust, unlike most other titles on this list, focuses on a single topic: web services. It covers that area well, but it’s neither a beginner-friendly introduction such as The Secrets of Rust: Tools, nor a deep technical dive like Rust for Rustaceans. It’s most suited to those who want to get web-based Rust applications up and running quickly, giving readers a set of pre-selected options that will work, without going into too much detail on why those particular choices were made.
The best Rust books compared
Here’s a quick overview of the Rust books on this list showing their various features, strengths, and weaknesses
| Title | Author | Level | Strengths | Weaknesses | Best for |
|---|---|---|---|---|---|
| The Secrets of Rust: Tools | John Arundel | Beginner | Clear explanations | Less technical depth | Rust beginners and junior developers |
| The Rust Programming Language | Steve Klabnik et al | Beginner to intermediate | Comprehensive | Steep difficulty curve | Experienced programmers new to Rust |
| Effective Rust | David Drysdale | Intermediate | Actionable tips | Rather brief | Experienced Rust devs |
| Rust for Rustaceans | Jon Gjengset | Advanced | Deep analysis | Can be hard going | Those with CS backgrounds |
| Programming Rust | Jim Blandy et al | Advanced | Breadth | Somewhat unfocused | Senior devs needing reference material |
| Rust in Action | Tim McNamara | Advanced | Technical depth | Not beginner-friendly | Systems programmers |
| Zero to Production in Rust | Luca Palmieri | Intermediate | Realistic examples | Rather narrow focus | Web developers |
Top picks
Taking into account factors like reviews, recommendations, and Rust community consensus, these are the top three books for Rust developers today.
Best for beginners: The Secrets of Rust: Tools
For those new to Rust, or to programming in general, The Secrets of Rust: Tools is highly praised as a readable, even fun introduction that builds readers’ confidence by guiding them through several practical projects in Rust. It’s the ideal jumping-off point for a new developer’s Rust journey.
Best for low-level and systems programmers: Rust in Action
Tim McNamara’s Rust in Action targets Rust’s sweet spot of operating systems and kernel development. Readers without a thorough grounding in these topics may struggle, but it’s a solid book that demonstrates why Rust is a good choice in these low-level applications.
Best for experienced developers: Rust for Rustaceans
Rust for Rustaceans can be dense and difficult reading, but the material repays careful study with a more thorough understanding of the why of Rust. Rust demands that programmers approach their code in a fundamentally different way from most other languages, and Jon Gjengset’s book explains how to think in Rust at a deep level.
