Skip to content


Best Rust Books 2023

Updated April 5, 2023

Rust is a open source systems programming language sponsored and used by Mozilla Research. Rust is made to be a concurrent and practical level language. It is syntactically similar to C++. It is made to be better at memory safety without losing performance.  It was recently awarded  Rust the title of ‘most loved programming language’ in the Stack Overflow Developer Survey.

The Rust Programming Language

The Rust Programming Language, 2nd Edition
  • Klabnik, Steve (Author)
  • English (Publication Language)
  • 560 Pages - 02/28/2023 (Publication Date) - No Starch Press (Publisher)
by Steve Klabnik and Carol Nichols is the official Rust book and serves as a gentle introduction to Rust. Written by two members of the Rust core team. The Rust Programming Language, 2nd Edition is the official guide to Rust 2021: an open source systems programming language that will help you write faster, more reliable software. Rust provides control of low-level details along with high-level ergonomics, allowing you to improve productivity and eliminate the hassle traditionally associated with low-level languages.

Klabnik and Nichols, alumni of the Rust Core Team, share their knowledge to help you get the most out of Rust’s features so that you can create robust and scalable programs. You’ll begin with basics like creating functions, choosing data types, and binding variables, then move on to more advanced concepts, such as:

Ownership and borrowing, lifetimes, generics, traits, and trait objects to communicate your program’s constraints to the compiler
Smart pointers and multithreading, and how ownership interacts with them to enable fearless concurrency
How to use Cargo, Rust’s built-in package manager, to build, document your code, and manage dependencies
The best ways to test, handle errors, refactor, and take advantage of expressive pattern matching

In addition to the countless code examples, you’ll find three chapters dedicated to building complete projects: a number-guessing game, a Rust implementation of a command line tool, and a multithreaded server.

This is the best Rust book in 2023.

Programming Rust: Fast, Safe Systems Development 2nd Edition

Programming Rust: Fast, Safe Systems Development
  • Blandy, Jim (Author)
  • English (Publication Language)
  • 735 Pages - 07/20/2021 (Publication Date) - O'Reilly Media (Publisher)

Systems programming provides the foundation for the world’s computation. Writing performance-sensitive code requires a programming language that puts programmers in control of how memory, processor time, and other system resources are used. The Rust systems programming language combines that control with a modern type system that catches broad classes of common mistakes, from memory management errors to data races between threads.

With this practical guide, experienced systems programmers will learn how to successfully bridge the gap between performance and safety using Rust. Jim Blandy, Jason Orendorff, and Leonora Tindall demonstrate how Rust’s features put programmers in control over memory consumption and processor use by combining predictable performance with memory safety and trustworthy concurrency.

You’ll learn:

Rust’s fundamental data types and the core concepts of ownership and borrowing
How to write flexible, efficient code with traits and generics
How to write fast, multithreaded code without data races
Rust’s key power tools: closures, iterators, and asynchronous programming
Collections, strings and text, input and output, macros, unsafe code, and foreign function interfaces

This is the best Rust books in 2023.

Rust for Rustaceans: Idiomatic Programming for Experienced Developers

Rust for Rustaceans: Idiomatic Programming for Experienced Developers
  • Gjengset, Jon (Author)
  • English (Publication Language)
  • 280 Pages - 12/21/2021 (Publication Date) - No Starch Press (Publisher)

For developers who’ve mastered the basics, this book is the next step on your way to professional-level programming in Rust. It covers everything you need to build and maintain larger code bases, write powerful and flexible applications and libraries, and confidently expand the scope and complexity of your projects.

Author Jon Gjengset takes you deep into the Rust programming language, dissecting core topics like ownership, traits, concurrency, and unsafe code. You’ll explore key concepts like type layout and trait coherence, delve into the inner workings of concurrent programming and asynchrony with async/await, and take a tour of the world of no_std programming. Gjengset also provides expert guidance on API design, testing strategies, and error handling, and will help develop your understanding of foreign function interfaces, object safety, procedural macros, and much more.

You’ll Learn:

How to design reliable, idiomatic, and ergonomic Rust programs based on best principles
Effective use of declarative and procedural macros, and the difference between them
How asynchrony works in Rust – all the way from the Pin and Waker types used in manual implementations of Futures, to how async/await saves you from thinking about most of those words
What it means for code to be unsafe, and best practices for writing and interacting with unsafe functions and traits
How to organize and configure more complex Rust projects so that they integrate nicely with the rest of the ecosystem
How to write Rust code that can interoperate with non-Rust libraries and systems, or run in constrained and embedded environments

This is the best advanced Rust book in 2023.

Beginning Rust: Get Started with Rust 2021 Edition

Beginning Rust: Get Started with Rust 2021 Edition
  • Milanesi, Carlo (Author)
  • English (Publication Language)
  • 436 Pages - 12/16/2021 (Publication Date) - Apress (Publisher)

by Carlo Milanesi starts with the fundamentals of Rust, such as naming objects, controlling execution flow, and dealing with primitive types. You’ll learn how to conduct arithmetic, memory allocation, iterators, and input/output. You’ll concentrate on managing errors and leveraging Rust’s object-oriented capabilities to quickly construct powerful Rust programs once you’ve learned these essential skills.

Only a basic understanding of C or C++ programming and experience with a command console are required. You’ll be ready to construct simple Rust applications after finishing this book. This is the best Rust book for beginners in 2023.

Rust in Action

Rust in Action
  • McNamara, Tim (Author)
  • English (Publication Language)
  • 456 Pages - 08/10/2021 (Publication Date) - Manning (Publisher)

Rust in Action by Tim McNamara introduces the Rust programming language by exploring numerous systems programming concepts and techniques. You’ll be learning Rust by delving into how computers work under the hood. You’ll find yourself playing with persistent storage, memory, networking and even tinkering with CPU instructions. The book takes you through using Rust to extend other applications and teaches you tricks to write blindingly fast code. You’ll also discover parallel and concurrent programming. Filled to the brim with real-life use cases and scenarios, you’ll go beyond the Rust syntax and see what Rust has to offer in real-world use cases.

Rust in Action is a hands-on guide to systems programming with Rust. Written for inquisitive programmers, it presents real-world use cases that go far beyond syntax and structure. You’ll explore Rust implementations for file manipulation, networking, and kernel-level programming and discover awesome techniques for parallelism and concurrency. Along the way, you’ll master Rust’s unique borrow checker model for memory management without a garbage collector.

Command-Line Rust: A Project-Based Primer for Writing Rust CLIs

Command-Line Rust: A Project-Based Primer for Writing Rust CLIs
  • Youens-Clark, Ken (Author)
  • English (Publication Language)
  • 396 Pages - 02/22/2022 (Publication Date) - O'Reilly Media (Publisher)

For several consecutive years, Rust has been voted “most loved programming language” in Stack Overflow’s annual developer survey. This open source systems programming language is now used for everything from game engines and operating systems to browser components and virtual reality simulation engines. But Rust is also an incredibly complex language with a notoriously difficult learning curve.

Rather than focusing on the language as a whole, this guide teaches Rust using a single small, complete, focused program in each chapter. Author Ken Youens-Clark shows you how to start, write, and test each of these programs to create a finished product. You’ll learn how to handle errors in Rust, read and write files, and use regular expressions, Rust types, structs, and more.

Discover how to:

Use Rust’s standard libraries and data types such as numbers, strings, vectors, structs, Options, and Results to create command-line programs
Write and test Rust programs and functions
Read and write files, including stdin, stdout, and stderr
Document and validate command-line arguments
Write programs that fail gracefully
Parse raw and delimited text manually, using regular expressions and Rust crates
Use and control randomness

Rust Web Programming: A hands-on guide to developing, packaging, and deploying fully functional Rust web applications, 2nd Edition

Rust Web Programming: A hands-on guide to developing, packaging, and deploying fully functional Rust...
  • Flitton, Maxwell (Author)
  • English (Publication Language)
  • 666 Pages - 01/27/2023 (Publication Date) - Packt Publishing (Publisher)

Are safety and high performance a big concern for you while developing web applications? With this practical Rust book, you’ll discover how you can implement Rust on the web to achieve the desired performance and security as you learn techniques and tooling to build fully operational web apps.

In this second edition, you’ll get hands-on with implementing emerging Rust web frameworks, including Actix, Rocket, and Hyper. It also features HTTPS configuration on AWS when deploying a web application and introduces you to Terraform for automating the building of web infrastructure on AWS. What’s more, this edition also covers advanced async topics. Built on the Tokio async runtime, this explores TCP and framing, implementing async systems with the actor framework, and queuing tasks on Redis to be consumed by a number of worker nodes. Finally, you’ll go over best practices for packaging Rust servers in distroless Rust Docker images with database drivers, so your servers are a total size of 50Mb each.

By the end of this book, you’ll have confidence in your skills to build robust, functional, and scalable web applications from scratch.
What you will learn

Structure and build scalable Rust web apps by creating a basic to-do list web app
Manage authentication and databases in Rust web applications
Get to grips with wrapping web applications in distroless
Understand the building blocks of web development such as HTTPS, TCP, and middleware
Build app infrastructure on AWS using Terraform with databases, servers, load balancers, HTTPS, and URL routing
Build end-to-end tests using Postman
Build async systems implementing the actor model using Tokio

Zero To Production In Rust: An introduction to backend development

Zero To Production In Rust: An introduction to backend development
  • Palmieri, Luca (Author)
  • English (Publication Language)
  • 600 Pages - 03/14/2022 (Publication Date) - Independently published (Publisher)

Zero To Production is the ideal starting point for your journey as a Rust backend developer.
You will learn by doing: you will build a fully functional email newsletter API, starting from scratch.

You’ll learn how to:

Navigate and leverage Rust’s crates ecosystem
Structure your application to make it modular and extensible
Write tests, from single units to full-blown integration tests
Enforce your domain invariants using Rust’s type system
Authenticate and authorize users of your API
Implement a robust error handling strategy
Observe the state of your application using structured logs
Set up an extensive continuous integration and continuous deployment pipeline for your Rust projects

Hands-on Rust: Effective Learning through 2D Game Development and Play

Hands-on Rust: Effective Learning through 2D Game Development and Play
  • Wolverson, Herbert (Author)
  • English (Publication Language)
  • 344 Pages - 08/03/2021 (Publication Date) - Pragmatic Bookshelf (Publisher)

Rust is an exciting new programming language combining the power of C with memory safety, fearless concurrency, and productivity boosters – and what better way to learn than by making games. Each chapter in this book presents hands-on, practical projects ranging from “Hello, World” to building a full dungeon crawler game. With this book, you’ll learn game development skills applicable to other engines, including Unity and Unreal.

Rust is an exciting programming language combining the power of C with memory safety, fearless concurrency, and productivity boosters. With Rust, you have a shiny new playground where your game ideas can flourish.

Each chapter in this book presents hands-on, practical projects that take you on a journey from “Hello, World” to building a full dungeon crawler game. Start by setting up Rust and getting comfortable with your development environment. Learn the language basics with practical examples as you make your own version of Flappy Bird. Discover what it takes to randomly generate dungeons and populate them with monsters as you build a complete dungeon crawl game. Run game systems concurrently for high-performance and fast game-play, while retaining the ability to debug your program. Unleash your creativity with magical items, tougher monsters, and intricate dungeon design. Add layered graphics and polish your game with style.

Rust Atomics and Locks: Low-Level Concurrency in Practice

Rust Atomics and Locks: Low-Level Concurrency in Practice
  • Bos, Mara (Author)
  • English (Publication Language)
  • 249 Pages - 02/07/2023 (Publication Date) - O'Reilly Media (Publisher)

The Rust programming language is extremely well suited for concurrency, and its ecosystem has many libraries that include lots of concurrent data structures, locks, and more. But implementing those structures correctly can be very difficult. Even in the most well-used libraries, memory ordering bugs are not uncommon.

In this practical book, Mara Bos, leader of the Rust library team, helps Rust programmers of all levels gain a clear understanding of low-level concurrency. You’ll learn everything about atomics and memory ordering and how they’re combined with basic operating system APIs to build common primitives like mutexes and condition variables. Once you’re done, you’ll have a firm grasp of how Rust’s memory model, the processor, and the role of the operating system all fit together.

With this guide, you’ll learn:

How Rust’s type system works exceptionally well for programming concurrency correctly
All about mutexes, condition variables, atomics, and memory ordering
What happens in practice with atomic operations on Intel and ARM processors
How locks are implemented with support from the operating system
How to write correct code that includes concurrency, atomics, and locks
How to build your own locking and synchronization primitives correctly

Learn Rust Programming: Safe Code, Supports Low Level and Embedded Systems Programming with a Strong Ecosystem

Learn Rust Programming: Safe Code, Supports Low Level and Embedded Systems Programming with a Strong...
  • Matzinger, Claus (Author)
  • English (Publication Language)
  • 268 Pages - 06/30/2022 (Publication Date) - BPB Publications (Publisher)

by Claus Matzinger assists every programmer in learning Rust and filling in the gaps left by other programming languages in developing full-proof apps and systems. This book covers every vital feature a programmer requires, including basic principles, syntax, clean coding, application testing, popular libraries, and numerous examples and small programmes.

As a first step in understanding the language, this book tries to present a profoundly practical method for overcoming this learning curve. Using engaging coding challenges and practical projects, the reader can anticipate learning programming fundamentals, developing advanced concurrent code, contributing to open-source projects, and ultimately pursuing a career in Rust. In addition to programming, this book covers the fundamentals of software engineering to develop maintainable and well-documented projects with the help of built-in tools.

As novice software engineers, readers of this book will be able to develop excellent software independently as part of a bigger team. Using Rust, they can join one of the numerous crypto, gaming, IoT, or cloud infrastructure organizations to mark their success of knowledge. What you will learn

● Learn Rust’s syntax, variables, control structures, enums, and traits.
● Write unit tests, integration tests, and documentation for the software codes.
● Use data structures, commands for running cargo, and any third-party libraries.
● Create durable and maintainable programmes by structuring code correctly.
● Use generics, lifetimes, I/O runtimes, concurrency, and futures in your code.
● Developing declarative macros and taking advantage of heap memory.

© 2023 ReactDOM

As an Amazon Associate I earn from qualifying purchases.