I have always learned best by building from scratch and teaching others.

Whenever I want to really understand an emerging or complex systems area, writing about it and writing code for it forces me to slow down. It forces me to find the core invariants, work through the math, and separate what is fundamentally true about physics and hardware from whatever happens to be trending on social media this week.

This repository—the four textbook volumes, TinyTorch, our MLSys·im simulator, and the hands-on hardware kits—is my open workshop and teaching lab. It is how I clarify my own thinking for my students at Harvard, my research lab, and open benchmarking efforts like MLPerf. Putting it all out in the open is my way of giving back to the community. If following along helps you on your own engineering journey, I couldn't be happier to share it with you.

Yes, and I want to be completely transparent about it.

I use LLMs and modern AI tools throughout my workflow—much like an author might work with an editor, research assistant, or sounding board. They are wonderful for brainstorming analogies, drafting early scaffolding, searching across research papers, and exploring how to explain tricky concepts more clearly. In a field that moves as fast as ML systems, these tools help me keep an ambitious, four-volume open curriculum moving forward alongside full-time university teaching and research.

At the same time, I am very thoughtful and deliberate about how I use them: I only release material after I have personally derived, coded, and verified it myself.

Language models can write very smooth prose that sounds right on the surface while hiding subtle mathematical or physical errors. Because this curriculum is meant to teach real-world engineering, accuracy and pedagogical care come first:

• Executable Python code and MLSys·im: We ground every quantitative concept in runnable code. The derivations, latency models, memory calculations, and scaling curves in these books are backed by executable Python cells right in the text, or cross-checked with our fleet simulator, MLSys·im. If there is a number or chart in a chapter, you can run the code and verify it against real hardware specifications.
• Classroom-tested pedagogy: A textbook is more than an encyclopedia of facts; it is a learning journey. Knowing what order to introduce ideas, where students typically stumble, and what to leave out to keep mental models clean comes from years of teaching in the classroom and listening to students in office hours.
• Automated quality checks: Every commit runs through our open-source validation suite (binder), which automatically checks that units balance, code references point to real definitions, citations resolve, and formatting remains consistent.
• Community and peer review: This entire project is open source on GitHub. I am deeply grateful to the students, university colleagues, and industry engineers who read drafts, point out mistakes, and suggest improvements.

Ultimately, tools are here to help us create, but authorship is about taking personal care and responsibility. Every concept, code snippet, and diagram in this curriculum has been reviewed and vetted by me, and I hope it serves you well in your learning journey.

Each volume also includes a detailed Note on AI Assistance with more information on how tools are used and verified.

This is for anyone who wants to understand how intelligent systems actually run, not just how models are trained: curious students, software engineers transitioning into ML infrastructure, hardware architects, and educators designing courses.

All I assume is that you can program in Python and have encountered basic machine learning ideas (like what a neural network or a loss function is). We build all the systems concepts from the ground up. You do not need a prior background in computer architecture, networking, or distributed systems. Volume I starts at the physical foundations, and the rest of the curriculum (TinyTorch, interactive labs, hardware kits, and the simulator) lets you build intuition with your own hands.

They differ in systems scope, not in depth or rigor. Both are equally quantitative.

Volume I is the single-node world: how an ML system works on one machine with a handful of accelerators, from the memory hierarchy and single-kernel efficiency up through quantization and on-device deployment. Volume II is the fleet-scale world: clustering thousands of accelerators across high-speed fabrics, 3D parallelism, network fault tolerance, and datacenter-scale serving.

Volume II does not assume you have read Volume I cover-to-cover, so if you already have strong single-node systems foundations, you can jump straight in. But if you want the complete picture from the silicon up, starting with Volume I will give you the cleanest mental models. It's a natural progression—much like Hennessy and Patterson's Computer Organization and Design followed by Computer Architecture: A Quantitative Approach. Volumes III (Agentic Systems) and IV (Physical AI) push the boundary even further into autonomous loops and embodied robotics.

You can absolutely just read the book! Each volume is written to stand completely on its own as a self-contained textbook.

The companion tools—TinyTorch, the interactive Marimo labs, the hardware kits, the MLSys·im simulator, and StaffML interview practice—are there whenever you want to take your understanding deeper. I built them because I found that while reading builds mental models, building and measuring make those concepts unforgettable. But there is zero pressure to do everything at once. Feel free to start with the book, and reach for the hands-on pieces whenever you want an idea to turn into muscle memory.

I love classic deep learning books—texts like Goodfellow, Bengio, and Courville's Deep Learning, Bishop's books, d2l.ai, and fast.ai are fantastic for learning the mathematics, architectures, and optimization of machine learning models.

This curriculum starts where those books leave off. It treats the model not as the entire universe, but as one computational component inside an end-to-end system that must ingest streaming data, run on real silicon under tight power and thermal budgets, serve user queries within millisecond deadlines, and operate reliably across thousands of machines.

You can finish a great deep learning course knowing all about backpropagation and attention, yet still wonder: Why is our GPU cluster idling at 30% utilization? Why did serving memory blow up from the KV cache? How do we synchronize gradients across high-speed interconnects without stalling?

That systems gap is what we focus on. Learn the machine learning fundamentals from those wonderful books, and then come here to learn how to make them fly in the real world.

It is an easy question to ask, especially because "ML systems" and "MLOps" sound very similar, and there are fantastic practitioner books in that space (such as Chip Huyen's Designing Machine Learning Systems).

MLOps books focus primarily on operational pipelines: how to configure feature stores, orchestrate workflow DAGs, and deploy services with today's industry tooling. They are extremely valuable practical guides.

This curriculum focuses on the engineering physics underneath: the hardware limits, quantitative trade-offs, and first principles that explain why those tools are designed the way they are, and what computational laws they can never escape—memory bandwidth, network latency, energy consumption, and hardware failure rates.

I often compare it to the difference between following a recipe and understanding culinary science. A recipe gives you exact steps for today's dish: this temperature, this pan, this many minutes. It works beautifully until the oven changes, an ingredient is missing, or the scale grows ten-fold. Understanding how heat, salt, fat, and time interact is different. It allows you to cook in any kitchen, debug a dish when things go sideways, and invent entirely new recipes.

Practitioner guides show you how to assemble today's popular software stack. This book teaches you the underlying science, so you can reason about any stack, debug the one that is failing, and design the systems of tomorrow.

Books like Barroso, Hölzle, and Clidaras's The Datacenter as a Warehouse-Scale Computer are masterclasses in engineering. They offer an incredible, firsthand look at how world-class teams architected real-world hyperscale infrastructure. We admire that work deeply, and our goal is to complement it rather than compete with it:

1. A progressive curriculum, not just a reference. A synthesis monograph captures a mature, finished architecture for seasoned practitioners. This series is designed as an interactive learning curriculum that takes you by the hand—starting from a single neuron and memory hierarchy on one chip (Volume I) all the way to multi-node clusters and warehouse-scale fleets (Volume II), with quantitative exercises and self-check questions along the way.

2. Vendor-neutral foundations. While single-organization retrospectives describe specific production choices, this curriculum generalizes across diverse accelerator architectures (GPUs, TPUs, custom ASICs) and deployment targets (cloud clusters to milliwatt microcontrollers). We emphasize the enduring mathematical and physical trade-offs so your knowledge transfers across any hardware generation.

3. Hands-on and living. A published monograph is a snapshot in time. This is an open, living workshop surrounded by runnable code you build yourself (TinyTorch), open hardware kits, cluster simulation (MLSys·im), and community-contributed improvements.

A warehouse-scale reference shows you how a legendary machine was built. This curriculum aims to give you the intuition and skills to design the next one.

It is a question I think about constantly as both an educator and an engineer!

Language models are astonishing at retrieval, code generation, and summarizing facts. If a paragraph in a textbook only delivers a fact you could look up in three seconds with a prompt, it hasn't earned its place.

What a textbook uniquely provides is perspective and a coherent mental model.

When learning a deep engineering discipline, the hardest challenge is rarely finding individual facts—it is discovering the right sequence in which to absorb ideas, understanding how trade-offs constrain one another, and learning what not to worry about so your mental model stays clean. Deciding what to leave out is one of the most important pedagogical choices an author makes.

Bruce Davie put this wonderfully in his essay “Textbooks in Tokenland” (Systems Approach): language models generate text without communicative intent, while a textbook represents an intentional journey between a teacher and a student to build a shared understanding of how the world works.

Rather than viewing textbooks and LLMs in opposition, we bring them together. The book provides the principled structure and quantitative narrative, while tools like our built-in SocratiQ tutor and interactive Marimo notebooks let you converse, ask questions, and test your understanding dynamically. Use the textbook for perspective, and use AI to explore!

Yes, completely! Every volume is free to read online at mlsysbook.ai.

The entire textbook is open source under a Creative Commons license (CC BY-NC-SA 4.0), which means you are welcome to read, share, and adapt it for non-commercial educational use with attribution. If you prefer print, a hardcopy edition is coming in 2026 with MIT Press.

The companion frameworks, simulators, and labs are also open source under permissive licenses (like MIT and Apache 2.0). Everything is right here in this repository—dive in and enjoy!