Rust GPU Concurrency Bundle

Whether you're just starting out or a fully-fledged Rust pro, this third Edition is a goldmine of knowledge about Rust. This book has been updated with Rust 1.85 and Rust 2024 Edition, and it takes you on a really structured learning path to write production-grade systems, async services, GPU compute kernels, Linux kernel modules, and Go-integrated libraries.

The book is built around a single, progressive application, and every chapter adds a functional layer to a real Linux system-metrics tool. The knowledge you gain from this book, is working and evolving codes that you can study, extend, and own. You'll get the hang of ownership and borrowing, handle the borrow checker, build concurrent and async programs with Tokio, manage memory without a garbage collector, and use Rust in domains that were once reserved exclusively for C and C++.

Whatever stage you're at, whether you're just starting out and writing your first function or you're a seasoned engineer migrating a critical service to Rust, this strong practically focussed book has got you covered.

• Dive in-depth into ownership model and eliminate memory bugs at compile time.
• Build async, concurrent programs using Tokio without data races or deadlocks.
• Design production-grade error types with ‘thiserror’ and ‘anyhow’ crates.
• Write GPU compute kernels and monitor GPU metrics.
• Integrate Rust libraries into existing Go applications via application binary interfaces.
• Write a loadable Linux kernel module entirely.
• Manage heap memory using Box, Rc, Arc, and smart pointer types.
• Leverage Rust 2024 Edition's new safety rules and migration workflow.
• Make use of Cargo workspaces, features, and optional dependencies to structure projects.

1. Why Rust in 2025?
2. Setting up Rust 1.85 Development Environment
3. Core Language Essentials
4. Structs and Data Modeling
5. Enums, Pattern Matching, and Error Handling
6. Ownership, Borrowing, Lifetimes, and Raw Pointers
7. Packages, Crates, and Full Command Suite
8. Rust Standard Library
9. Smart Pointers and Memory Management
10. Concurrency, Parallelism, and Async Programming
11. Rust 2024 Edition
12. Rust for GPU and CUDA Programming
13. Rust for Go Developers
14. Rust for Linux Kernel

This book is all about getting hands-on with different toolchains that connect Rust to NVIDIA hardware. There's RustaCUDA for safe host-side control, the Rust-CUDA project for writing kernels in pure Rust, and NVIDIA's experimental cuda-oxide compiler with its typed launches and async execution graphs.

We're going to build one Cargo workspace that keeps on growing. It'll include device queries, launch planning, Rust-written kernels, memory optimization, parallel reductions and scans, multi-stream pipelines, matrix multiplication benchmarked against cuBLAS, a Monte Carlo option pricer validated against a closed formula, and a complete batched inference application measured against a Python baseline. We'll check every result against a CPU reference, and the reports will give accurate numbers, including where libraries outperform hand-written kernels and where experimental toolchains are still a work in progress.

• Launch, synchronize, and verify GPU kernels with ownership-managed device memory.
• Write real CUDA kernels using Rust-CUDA and cuda-oxide.
• Plan grids, blocks, and warps for 2D workloads.
• Accelerate transfer speeds with pinned memory and coalesced access patterns.
• Build race-free thread cooperation using shared memory, barriers, and atomics.
• Overlap transfers with computation using streams, events, and async Rust pipelines.
• Optimize matrix multiplication and benchmark against cuBLAS ceiling.
• Wrap CUDA C library safely with handles, error enums, and Drop.
• Ship complete batched GPU inference application against Python baselines.
• Diagnose performance with Nsight Systems, Nsight Compute, and compute-sanitizer.

1. New Beneficiary of GPU Computing
2. Thinking in Threads
3. Commanding GPU
4. Writing GPU Kernels
5. Cleaner Kernels with cuda-oxide
6. Mastering GPU Memory
7. Making Threads Cooperate
8. Keeping GPU Busy
9. Delivering Real Math
10. Borrowing NVIDIA's Muscle
11. Shipping Complete GPU Application
12. Proving Performance

The bottleneck is not your kernel. In fact, it almost never is.

After spending enough time in Nsight, the way you read a timeline becomes as intuitive as a mechanic listening to an engine. The same faults keep cropping up, such as a GPU with thousands of cores sitting idle behind a blocking copy, a single default stream or a host thread frozen at a synchronisation point that was never necessary. This book is about identifying that fault early and eliminating it.

Designed for programming professionals, this book is written for GPU developers, Rust engineers and AI practitioners who want their devices to be busy, not just correct. Our approach is to stay in pure Rust throughout, using cuda-oxide for SIMT kernels and cutile-rs for the tile model. We also rely heavily on the type system to ensure that data races fail at compile time rather than at 3 AM during production. We will overlap transfers with compute using streams and pinned memory, build a staging ring that pipelines every stage and feed the GPU through Tokio producers with bounded-channel backpressure. Each technique is profiled, verified against a CPU reference and measured.

• Profile before you optimise, and let Nsight Systems show you who is actually waiting.
• Write SIMT kernels in pure Rust where data races fail at compile time.
• Treat default stream as the enemy of overlap, and fork your own.
• Overlap copies with compute using pinned memory and a staging ring.
• Reach for reduction ladder instead of atomics when summing on the device.
• Express element-wise work as tile kernels, and let compiler map the hardware.
• Keep the GPU fed with Tokio producers and bounded-channel backpressure.
• Verify every kernel against CPU reference before you trust its timing.
• Weigh throughput against latency, since tuning for one quietly taxes the other.
• Know when to stop, because past a point concurrency only adds bookkeeping.

1. Rust’s Threads, Timing and Ownership
2. CPU versus GPU Execution
3. SIMT Kernels, Blocks and Grids
4. Race-Free Parallel Kernels
5. Asynchronous GPU Execution
6. Overlapping Transfers with Streams
7. Tile Programming with cutile-rs
8. Async GPU Pipelines with Tokio
9. Throughput, Latency and Bottlenecks

If you're a programmer looking for a hands-on guide to GPU programming, Rust techniques and AI principles, this book is for you. It's designed to help you make the most of your device's processing power.