The Ultimate Rust Bundle

This book takes you from zero Rust knowledge to expert-level proficiency. It teaches every core language feature, the standard library, modern tooling, and the most important ecosystem crates through complete, production-quality examples. You will learn not only how Rust works but why it is designed this way, so that writing safe, idiomatic, efficient, and maintainable Rust becomes second nature.

This book takes experienced Rust developers beyond ownership, borrowing, and basic concurrency into the deep machinery of the language — variance, memory layout, trait resolution, atomic operations, async internals, unsafe contracts, FFI boundaries, allocator design, and performance engineering. Each chapter builds precise mental models with complete, compilable examples, explaining not only how features work but why they exist, when to use them, what trade-offs they entail, and how they compose into production-grade systems.

This book is a complete guide to understanding and building large language model inference engines in Rust. It takes you from the mathematical foundations of the transformer architecture through tokenization, attention mechanisms, KV caching, quantization, batching strategies, GPU and CPU optimization, distributed serving, and production deployment. Along the way, you will see idiomatic Rust code examples, performance benchmarks, comparisons with leading frameworks like vLLM, TGI, llama.cpp, Candle, Burn, and mistral.rs, and practical insights for shipping inference systems that rival the best open-source and commercial offerings. Whether you are a systems programmer interested in AI infrastructure or an ML engineer curious about the Rust ecosystem, this book gives you the depth to build, optimize, and understand.

This book teaches you how to write production-grade systems software in Rust. You will learn not only the syntax and idioms of the language, but also how Rust works internally: its ownership model, memory layout, compilation pipeline, concurrency guarantees and performance characteristics. Through complete, self-contained projects, you will build a robust command-line tool, a binary file parser, a concurrent worker pool, a TCP server, an asynchronous networking service and a C interoperability library. Each concept is grounded in verified sources from the Rust documentation, The Rustonomicon, compiler internals and authoritative systems programming references. The book assumes you already know how to program in a systems language and takes you to the level where you can design, implement, debug, optimize and deploy Rust systems that are fast, correct and maintainable.

You have used web frameworks. You know how to spin up an Axum or Actix server in minutes. But do you understand what happens when a browser sends a request and your server sends back a response? This book takes you on a hands-on journey from raw TCP sockets through the full stack of HTTP/1.1, HTTP/2, TLS, routing, middleware, templating, REST APIs, testing, benchmarking, and deployment. Every chapter adds a layer to a production-quality web server built entirely in Rust using Tokio and carefully chosen crates. By the end, you will not only have a working server but also the deep intuition that makes you a better developer no matter what tools you eventually use.

This book shows you how to design, build, test, deploy and operate production-ready web applications with Rust and the Axum framework. Using a task management API called Taskflow as a running example, you’ll start with the fundamentals and gradually work your way into more advanced topics such as authentication, database integration, real-time communication, observability and containerized deployment. The examples are explained in context so you can follow along and understand how each part fits into the application. The book assumes you have some basic knowledge of Rust syntax, while introducing the web development and async concepts you need along the way. It targets Axum 0.8.x, Tokio 1.x and Rust edition 2021.

A debugger is not magic. It is a careful orchestration of operating system primitives, CPU features, and compiler-generated metadata that together let you pause a running program, inspect its state, and control its execution one instruction at a time. This book teaches you how to build a fully functional source-level debugger from scratch in Rust. Starting from the fundamentals of processes, virtual memory, and executable formats, we progressively implement every feature a real debugger needs: process attachment, software and hardware breakpoints, single stepping, register inspection, memory read and write, symbol resolution, stack unwinding, call frame inspection, DWARF debug information parsing, source-level debugging, expression evaluation, watchpoints, multithreaded debugging, shared library support, signal handling, and remote debugging concepts. Every concept is accompanied by complete, production-quality Rust code that builds upon previous chapters into a cohesive debugger. By the end of this book, you will have built a capable debugger entirely in Rust and gained deep insight into how programs execute, how operating systems manage processes, and how compilers encode the information needed to map machine code back to source code.

This book teaches you how to implement a complete x86_64 hardware-assisted hypervisor entirely in Rust. Starting from an empty project, you will build every component: CPU virtualization using Intel VT-x (with AMD-V parallels), extended page tables for memory isolation, VM exit handling, interrupt and APIC virtualization, device emulation, VirtIO paravirtualized devices for storage and networking, ACPI table generation, guest firmware loading, and multi-vCPU scheduling. Every concept is grounded in working, compilable Rust code with line-by-line explanations. No placeholders, no pseudocode, no hand-waving. If you have systems programming experience and want to understand how virtualization really works at the hardware level, this book will take you there.

This book teaches you how to build a complete, production-quality programming language from scratch using Rust. Over twenty chapters, you will design and implement every component of a real language called Rune: the lexer, parser, type system, interpreter, bytecode virtual machine, native code generator, standard library, and full developer tooling chain including a REPL, formatter, linter, and language server. Every chapter includes complete, compilable Rust code with detailed explanations of design trade-offs, performance considerations, and common pitfalls. By the end, you will have built a feature-complete language and deep understanding of how programming languages work internally.

GPU parallel computing has fundamentally changed how software achieves performance, but writing kernels has historically demanded deep expertise in low-level hardware details and C++ era programming patterns. This book shows Rust developers how to harness NVIDIA GPUs using CUDA Rust, the emerging ecosystem that brings memory safety, expressive type systems, and modern tooling to GPU programming.

You will learn both of NVIDIA's official CUDA Rust tracks: the SIMT-style cuda-oxide compiler backend for fine-grained thread-level control, and the tile-based cutile-rs framework for safe, high-level kernel authoring. Along the way, you will build a solid understanding of GPU architecture, memory hierarchies, synchronization, and performance optimization. Every chapter includes complete, runnable code examples and explains the why behind each concept, not just the how. This is a practical guide for Rust programmers ready to write production-quality GPU kernels without sacrificing the safety and clarity that make Rust compelling.

Adding features like autocomplete, go-to-definition, hover documentation, real-time diagnostics and refactoring tools to a programming language is one of the most rewarding challenges in developer tooling. The Language Server Protocol turned this into a shared infrastructure problem, letting one language-aware server power dozens of editors. This book takes you from zero to a fully functional, production-ready language server written in Rust. You will learn the protocol inside out, build parsing and analysis infrastructure, implement every major IDE feature and ship a server that integrates with Visual Studio Code, Neovim and any LSP-compatible editor. Along the way you will gain deep practical knowledge of async Rust, compiler design basics, text-processing algorithms and the architecture behind modern development environments. No prior LSP experience is required; only comfort with Rust fundamentals and a willingness to build something real.

This book is a practical, production-focused guide for engineers and organizations incrementally introducing Rust into mature C codebases. It shows how to evaluate existing systems, design safe interoperability boundaries, migrate components without destabilizing production behavior, and maintain working software throughout the transition. The emphasis is on engineering realism over hype: when Rust delivers real value, when it does not, what costs are involved, and exactly how to proceed step by step with complete, runnable examples at every stage.