Rust

I wrote this book to show exactly what happens when you add Rust to the kernel. Not as a toy. Not as a single driver in a conference demo. It's a full module that covers process management, memory allocation, file systems, networking, device drivers, inter-process communication, and even machine learning inference. It's all built on safe abstractions, all compiled into one loadable binary, all tested on a running kernel. You'll find that each chapter adds new source files to the same module.

Language models guess. Knowledge graphs know. Rusty Graph shows you how to build a local AI agent whose memory is a real knowledge graph — typed, validated, reasoned over, and queryable with SPARQL — all inside a single static Rust binary. No JVM. No Docker sidecar. No Python runtime bolted to the side. You will build Ares a research-assistant agent that observes papers, forms beliefs, makes promises to other agents, and tracks the provenance of every fact it holds. Chapter by chapter, Ares grows from an empty Cargo workspace into a full pipeline: > load → reason → validate → query → answer All of it in under a thousand lines of idiomatic Rust, using three crates that actually work today: `oxigraph`, `reasonable`, and `rudof_lib`. `grapfeo` You will learn how to- Model a domain as RDF triples and load them into an embedded store. - Write RDFS and OWL 2 RL axioms that infer trust, identity, and inverse relationships — automatically. - Guard your graph with SHACL shapes that reject bad data at the boundary, not in production. - Query everything with SPARQL, from simple lookups to federated queries across named graphs. - Wire the graph into a hybrid RAG pipeline so your LLM answers are grounded in facts, not vibes. Who it is forRust developers building agents, assistants, or any system where the answer "the model said so" is not good enough. You should be comfortable with Cargo and traits. You do **not** need any prior semantic-web background — every concept is introduced through Ares before any formal definition appears. Why Rust, why nowLocal agents are the next deployment target: a user's laptop, a Raspberry Pi, a WASM sandbox. Python cannot go there comfortably. Rust can. This book is the missing manual for the Rust side of the semantic web — the one that tells you exactly which crates work, where the ecosystem is thin, and how to ship anyway. Stop hoping your model tells the truth. Give it a graph that does.

Unlock NVIDIA GPU performance from Rust. This practical guide takes you from GPU architecture and memory hierarchies to writing and optimizing real CUDA Rust kernels. Explore both official Rust CUDA approaches with runnable examples and learn how to build fast, production-ready GPU code without giving up Rust’s safety and clarity.

We'll be writing kernels in Rust and seeing how they match up with their C++ equivalents. If you feed a GPU properly, you'll see bandwidth quadruple from just one changed subscript. It'll get you working with thousands of threads, pricing a financial option based on an exact formula, and shipping an inference pipeline that outruns its Python equivalent for reasons you can name.

Explore the power of Rust with "Rust Projects: Write a Redis Clone". This hands-on guide takes you through building a Redis-inspired database from the ground up, introducing key programming concepts like TCP connections, the RESP protocol, and concurrency. Following the CodeCrafters challenge, this book gradually builds your skills, making complex topics accessible. Whether you're new to Rust or looking to deepen your understanding, this project-based journey offers practical, real-world insights into modern systems programming. The book contains 40% discount code for CodeCrafters.io!

What really happens between typing a SQL query and getting a result? Build a database engine from the ground up in Rust and find out. You’ll work through storage, indexing, concurrency, recovery and query processing while turning each chapter’s code into one working system.

Learn how modern LLM inference engines work by building one from scratch in Rust. From transformers and tokenization to KV caching, quantization, batching, and GPU optimization, this book combines theory, hands-on code, and performance engineering to help you create fast, production-ready AI systems.

In this book, we are building a complete working server, and again we rebuild the whole thing on a different framework. It's about testing out a new approach. If the architecture is honest, the second version costs almost nothing and the business logic never moves. We ran the test, and I let you watch the result rather than describing it.

The latest version of Rust (1.85) has some great new features, like async closures, more stable associated function return types, and const generics that are now mature enough to underpin serious numerical libraries. The linfa and smartcore ecosystems have developed into decent classical machine learning stacks. The Burn training framework feels native to Rust, not like it's been ported from it. The Candle makes it so that loading pre-trained transformer models is more of an engineering task than a research exercise. The crates that used to need all sorts of workarounds now just work.

Discover how to make Python data processing faster, leaner and ready to scale with Polars. Starting with the basics, this practical guide takes you all the way to production-grade pipelines for massive datasets, with clear explanations of how Polars works, why it is fast and how to get the best performance from it.

Build a real language server from the ground up in Rust. Learn how LSP works, then turn parsing, analysis and async Rust into autocomplete, diagnostics, go-to-definition, refactoring and more. By the end, you’ll have a production-ready server that works with VS Code, Neovim and other modern editors.

Go from your first line of Rust to building fast, safe, and production-ready applications with confidence. This practical guide explains every essential language feature, modern development tools, and key ecosystem crates through clear explanations and real-world examples, helping you write idiomatic, efficient and maintainable Rust code from day one.

This edition includes a deeper exploration of machine learning and natural language processing, which I am excited to share. I have added new chapters on nonlinear models, multivariate techniques, and text analysis. You will find implementations of algorithms like Support Vector Machines, Neural Networks, and Principal Component Analysis, all using Rust's powerful crates such as smartcore, linfa, and tch. These examples prove that Rust is the ideal tool for complex data analysis tasks.

From the fundamentals of TCP/IP to advanced packet manipulation and analysis techniques, we have delved deeply into the core concepts that power modern networks. The practical examples and hands-on approach were created to teach you real-world skills that you can immediately apply to your projects. Whether you're developing network applications, troubleshooting network issues, or automating network tasks, the knowledge in this book will help you succeed.