harvard-edge/cs249r_bookPublic

Machine Learning Systems: Foundations, Scaling, Agentic AI, and Physical AI (Vols I–IV) • Harvard CS249r | https://mlsysbook.ai

AI summary: The textbook and courseware for Harvard CS249r: Machine Learning Systems, covering edge ML to cloud infrastructure.

Stars
30.3K
+54 today
Forks
3.7K
Watchers
212
Open issues
5
Open PRs
7
Contributors
~130
Commits
26.3K
Branches
5

PythonOtherCreated Sep 6, 2023Last push 2d agoLatest release slides-latest+114 stars this week+1.2K this month

Quick answers

What is cs249r_book?
The textbook and courseware for Harvard CS249r: Machine Learning Systems, covering edge ML to cloud infrastructure.
What does cs249r_book do?
This repository hosts the comprehensive textbook, assignments, and underlying systems code for Harvard University's course on engineering artificially intelligent systems. It addresses the critical intersection of machine learning algorithms and the computer systems required to execute them efficiently. The technical curriculum dives deep into hardware-aware model optimization, embedded machine learning (TinyML), distributed training, and the orchestration of cloud-scale ML pipelines. What sets this apart is its rigorous, academic approach to the full ML lifecycle, treating AI not just as mathematics, but as complex engineering systems that must be optimized for power, latency, and throughput. It provides world-class educational material completely open to the public.
Who is cs249r_book for?
This material is intended for advanced computer science students, systems engineers, and ML practitioners looking to understand the intersection of hardware and AI. It requires strong programming skills (C++/Python) and a foundation in computer architecture.
How do I get started with cs249r_book?
Read the textbook directly on GitHub or follow the setup instructions in the README to build the TinyTorch environment.
How popular is cs249r_book on GitHub?
harvard-edge/cs249r_book has 30,263 stars and 3,745 forks on GitHub, and gained 114 stars in the last 7 days.
What license does cs249r_book use?
harvard-edge/cs249r_book is released under the Other license.

Star history

since Jul 29, 2026
010K20K30KJul 2026Sep 2026Oct 2026Nov 2026
30.3K stars as of Nov 19, 2026. Measured daily since Jul 29, 2026; GitHub no longer exposes earlier star timestamps.

Update history

2 recorded
  • Oct 31, 2026New release slides-latest (previously tinytorch-v0.2.0).
  • Oct 8, 2026New release tinytorch-v0.2.0 (previously vol1-v0.7.2).

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-16: 2 commits2025-11-17: 0 commits2025-11-18: 0 commits2025-11-19: 1 commit2025-11-20: 2 commits2025-11-21: 1 commit2025-11-22: 0 commits2025-11-23: 0 commits2025-11-24: 0 commits2025-11-25: 14 commits2025-11-26: 3 commits2025-11-27: 2 commits2025-11-28: 2 commits2025-11-29: 1 commit2025-11-30: 2 commits2025-12-01: 2 commits2025-12-02: 19 commits2025-12-03: 11 commits2025-12-04: 7 commits2025-12-05: 34 commits2025-12-06: 33 commits2025-12-07: 25 commits2025-12-08: 20 commits2025-12-09: 11 commits2025-12-10: 45 commits2025-12-11: 82 commits2025-12-12: 25 commits2025-12-13: 31 commits2025-12-14: 58 commits2025-12-15: 37 commits2025-12-16: 22 commits2025-12-17: 23 commits2025-12-18: 25 commits2025-12-19: 21 commits2025-12-20: 11 commits2025-12-21: 30 commits2025-12-22: 3 commits2025-12-23: 3 commits2025-12-24: 4 commits2025-12-25: 0 commits2025-12-26: 0 commits2025-12-27: 8 commits2025-12-28: 32 commits2025-12-29: 15 commits2025-12-30: 28 commits2025-12-31: 7 commits2026-01-01: 34 commits2026-01-02: 33 commits2026-01-03: 28 commits2026-01-04: 30 commits2026-01-05: 24 commits2026-01-06: 45 commits2026-01-07: 28 commits2026-01-08: 4 commits2026-01-09: 50 commits2026-01-10: 34 commits2026-01-11: 32 commits2026-01-12: 8 commits2026-01-13: 24 commits2026-01-14: 31 commits2026-01-15: 31 commits2026-01-16: 18 commits2026-01-17: 8 commits2026-01-18: 3 commits2026-01-19: 17 commits2026-01-20: 21 commits2026-01-21: 57 commits2026-01-22: 63 commits2026-01-23: 85 commits2026-01-24: 41 commits2026-01-25: 69 commits2026-01-26: 83 commits2026-01-27: 57 commits2026-01-28: 42 commits2026-01-29: 20 commits2026-01-30: 30 commits2026-01-31: 28 commits2026-02-01: 51 commits2026-02-02: 49 commits2026-02-03: 23 commits2026-02-04: 54 commits2026-02-05: 11 commits2026-02-06: 22 commits2026-02-07: 18 commits2026-02-08: 32 commits2026-02-09: 10 commits2026-02-10: 13 commits2026-02-11: 12 commits2026-02-12: 13 commits2026-02-13: 12 commits2026-02-14: 11 commits2026-02-15: 15 commits2026-02-16: 8 commits2026-02-17: 16 commits2026-02-18: 6 commits2026-02-19: 25 commits2026-02-20: 4 commits2026-02-21: 36 commits2026-02-22: 34 commits2026-02-23: 10 commits2026-02-24: 31 commits2026-02-25: 11 commits2026-02-26: 29 commits2026-02-27: 12 commits2026-02-28: 8 commits2026-03-01: 15 commits2026-03-02: 38 commits2026-03-03: 19 commits2026-03-04: 34 commits2026-03-05: 14 commits2026-03-06: 27 commits2026-03-07: 21 commits2026-03-08: 19 commits2026-03-09: 15 commits2026-03-10: 9 commits2026-03-11: 7 commits2026-03-12: 12 commits2026-03-13: 25 commits2026-03-14: 26 commits2026-03-15: 50 commits2026-03-16: 48 commits2026-03-17: 17 commits2026-03-18: 43 commits2026-03-19: 27 commits2026-03-20: 34 commits2026-03-21: 57 commits2026-03-22: 44 commits2026-03-23: 45 commits2026-03-24: 54 commits2026-03-25: 52 commits2026-03-26: 1 commit2026-03-27: 1 commit2026-03-28: 2 commits2026-03-29: 1 commit2026-03-30: 12 commits2026-03-31: 56 commits2026-04-01: 53 commits2026-04-02: 107 commits2026-04-03: 38 commits2026-04-04: 16 commits2026-04-05: 89 commits2026-04-06: 5 commits2026-04-07: 59 commits2026-04-08: 60 commits2026-04-09: 57 commits2026-04-10: 11 commits2026-04-11: 3 commits2026-04-12: 16 commits2026-04-13: 11 commits2026-04-14: 14 commits2026-04-15: 40 commits2026-04-16: 129 commits2026-04-17: 71 commits2026-04-18: 163 commits2026-04-19: 63 commits2026-04-20: 295 commits2026-04-21: 99 commits2026-04-22: 262 commits2026-04-23: 64 commits2026-04-24: 145 commits2026-04-25: 132 commits2026-04-26: 107 commits2026-04-27: 70 commits2026-04-28: 61 commits2026-04-29: 42 commits2026-04-30: 107 commits2026-05-01: 51 commits2026-05-02: 38 commits2026-05-03: 150 commits2026-05-04: 126 commits2026-05-05: 70 commits2026-05-06: 208 commits2026-05-07: 122 commits2026-05-08: 25 commits2026-05-09: 60 commits2026-05-10: 55 commits2026-05-11: 176 commits2026-05-12: 227 commits2026-05-13: 69 commits2026-05-14: 44 commits2026-05-15: 29 commits2026-05-16: 13 commits2026-05-17: 55 commits2026-05-18: 152 commits2026-05-19: 117 commits2026-05-20: 55 commits2026-05-21: 117 commits2026-05-22: 69 commits2026-05-23: 74 commits2026-05-24: 75 commits2026-05-25: 83 commits2026-05-26: 143 commits2026-05-27: 124 commits2026-05-28: 192 commits2026-05-29: 79 commits2026-05-30: 104 commits2026-05-31: 146 commits2026-06-01: 57 commits2026-06-02: 118 commits2026-06-03: 304 commits2026-06-04: 290 commits2026-06-05: 64 commits2026-06-06: 160 commits2026-06-07: 62 commits2026-06-08: 101 commits2026-06-09: 49 commits2026-06-10: 107 commits2026-06-11: 180 commits2026-06-12: 58 commits2026-06-13: 84 commits2026-06-14: 11 commits2026-06-15: 98 commits2026-06-16: 27 commits2026-06-17: 108 commits2026-06-18: 4 commits2026-06-19: 8 commits2026-06-20: 14 commits2026-06-21: 25 commits2026-06-22: 59 commits2026-06-23: 28 commits2026-06-24: 16 commits2026-06-25: 16 commits2026-06-26: 14 commits2026-06-27: 15 commits2026-06-28: 10 commits2026-06-29: 17 commits2026-06-30: 11 commits2026-07-01: 3 commits2026-07-02: 31 commits2026-07-03: 16 commits2026-07-04: 1 commit2026-07-05: 5 commits2026-07-06: 0 commits2026-07-07: 14 commits2026-07-08: 5 commits2026-07-09: 0 commits2026-07-10: 34 commits2026-07-11: 12 commits2026-07-12: 14 commits2026-07-13: 29 commits2026-07-14: 13 commits2026-07-15: 19 commits2026-07-16: 4 commits2026-07-17: 21 commits2026-07-18: 35 commits2026-07-19: 1 commit2026-07-20: 0 commits2026-07-21: 1 commit2026-07-22: 1 commit2026-07-23: 1 commit2026-07-24: 6 commits2026-07-25: 1 commit2026-07-26: 6 commits2026-07-27: 9 commits2026-07-28: 6 commits2026-07-29: 0 commits2026-07-30: 0 commits2026-07-31: 2 commits2026-08-01: 1 commit2026-08-02: 0 commits2026-08-03: 50 commits2026-08-04: 30 commits2026-08-05: 59 commits2026-08-06: 43 commits2026-08-07: 25 commits2026-08-08: 24 commits2026-08-09: 14 commits2026-08-10: 99 commits2026-08-11: 40 commits2026-08-12: 73 commits2026-08-13: 52 commits2026-08-14: 76 commits2026-08-15: 82 commits2026-08-16: 40 commits2026-08-17: 150 commits2026-08-18: 30 commits2026-08-19: 4 commits2026-08-20: 4 commits2026-08-21: 4 commits2026-08-22: 5 commits2026-08-23: 17 commits2026-08-24: 38 commits2026-08-25: 29 commits2026-08-26: 47 commits2026-08-27: 69 commits2026-08-28: 49 commits2026-08-29: 112 commits2026-08-30: 48 commits2026-08-31: 86 commits2026-09-01: 35 commits2026-09-02: 40 commits2026-09-03: 81 commits2026-09-04: 133 commits2026-09-05: 29 commits2026-09-06: 48 commits2026-09-07: 150 commits2026-09-08: 21 commits2026-09-09: 73 commits2026-09-10: 179 commits2026-09-11: 130 commits2026-09-12: 100 commits2026-09-13: 30 commits2026-09-14: 221 commits2026-09-15: 126 commits2026-09-16: 97 commits2026-09-17: 105 commits2026-09-18: 77 commits2026-09-19: 72 commits2026-09-20: 182 commits2026-09-21: 142 commits2026-09-22: 171 commits2026-09-23: 15 commits2026-09-24: 4 commits2026-09-25: 4 commits2026-09-26: 4 commits2026-09-27: 4 commits2026-09-28: 99 commits2026-09-29: 187 commits2026-09-30: 94 commits2026-10-01: 72 commits2026-10-02: 37 commits2026-10-03: 72 commits2026-10-04: 26 commits2026-10-05: 87 commits2026-10-06: 119 commits2026-10-07: 43 commits2026-10-08: 65 commits2026-10-09: 86 commits2026-10-10: 111 commits2026-10-11: 49 commits2026-10-12: 157 commits2026-10-13: 265 commits2026-10-14: 86 commits2026-10-15: 114 commits2026-10-16: 62 commits2026-10-17: 49 commits2026-10-18: 118 commits2026-10-19: 142 commits2026-10-20: 428 commits2026-10-21: 50 commits2026-10-22: 74 commits2026-10-23: 16 commits2026-10-24: 38 commits2026-10-25: 16 commits2026-10-26: 41 commits2026-10-27: 80 commits2026-10-28: 28 commits2026-10-29: 37 commits2026-10-30: 101 commits2026-10-31: 14 commits2026-11-01: 6 commits2026-11-02: 26 commits2026-11-03: 27 commits2026-11-04: 29 commits2026-11-05: 116 commits2026-11-06: 105 commits2026-11-07: 21 commits2026-11-08: 4 commits2026-11-09: 4 commits2026-11-10: 4 commits2026-11-11: 4 commits2026-11-12: 0 commits2026-11-13: 0 commits2026-11-14: 0 commits
18,105 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Widely adopted

    30,263 stars

  • Very active

    18,105 commits in 52 weeks

  • Community-driven

    ~130 contributors

  • Well documented

    High community health score

  • Continuous integration

    Automated checks passing

  • Repeat trending

    5 trending appearances

What cs249r_book does

This repository hosts the comprehensive textbook, assignments, and underlying systems code for Harvard University's course on engineering artificially intelligent systems. It addresses the critical intersection of machine learning algorithms and the computer systems required to execute them efficiently. The technical curriculum dives deep into hardware-aware model optimization, embedded machine learning (TinyML), distributed training, and the orchestration of cloud-scale ML pipelines. What sets this apart is its rigorous, academic approach to the full ML lifecycle, treating AI not just as mathematics, but as complex engineering systems that must be optimized for power, latency, and throughput. It provides world-class educational material completely open to the public.

This material is intended for advanced computer science students, systems engineers, and ML practitioners looking to understand the intersection of hardware and AI. It requires strong programming skills (C++/Python) and a foundation in computer architecture.

  • Full-Stack ML Curriculum: covers the entire spectrum of ML systems, from training models on distributed clusters to deploying them on microcontrollers.
  • TinyTorch Implementation: includes a custom, educational deep learning framework designed specifically to teach the internals of ML runtimes.
  • Hardware-Aware Optimization: provides deep dives into quantization, pruning, and compiling models for specific hardware architectures.
  • Continuous Validation: utilizes GitHub Actions to automatically test the course code and validate the Markdown builds of the textbook.
  • Multi-Language Support: offers translations of the core materials into multiple languages, expanding accessibility for global learners.

Where teams use it

Systems Engineering Education

Computer science students use the material to understand how popular frameworks like PyTorch and TensorFlow actually work under the hood.

Edge AI Development

Embedded engineers study the TinyML sections to learn techniques for deploying neural networks onto severely resource-constrained microcontrollers.

Infrastructure Scaling

MLOps professionals reference the cloud sections to design more efficient, distributed training pipelines that maximize GPU utilization.

Curriculum Development

Educators at other institutions fork the repository to adapt the high-quality assignments and textbook for their own advanced systems courses.

Getting started: Read the textbook directly on GitHub or follow the setup instructions in the README to build the TinyTorch environment.

README

dev branch

Machine Learning Systems

English • 中文 • 日本語 • 한국어
The translations follow an earlier version of this page. Help bringing them up to date is welcome.

An open textbook series on how machine learning systems are built and why they are built that way, with companion tools for building, measuring, and teaching them.

License: per component Cite Fund Us

GitHub stars

Build status on dev

Vol I Vol II Vol III Vol IV
TinyTorch MLSys·im Labs Kits Slides Instructors StaffML

📘 Textbook Series • 📗 Vol I • 📘 Vol II (Preview) • 🟣 Vol III (Dev) • 🌲 Vol IV (Dev)
🔥 TinyTorch • 🔬 Labs • 🧰 Kits • 🔮 MLSys·im • 🎓 Instructors • 💼 StaffML • Taxonomy

📚 Volume I is forthcoming in print from MIT Press.


Why This Curriculum Exists

The world is rushing to build AI systems. It is not yet engineering them.

AI engineering is the discipline of building efficient, reliable, and safe intelligent systems that operate in the real world, not models in isolation. It deserves a place alongside software engineering and computer engineering, and this curriculum teaches it the way computer architecture has long been taught, from first principles and with numbers a student can recompute.

Those numbers come from constraints. A model that scores well on a benchmark still has to fit in memory, meet a latency budget, stay within a power limit, and fail safely in front of real people. These constraints decide the architecture, and they follow laws that outlast any framework or chip. Memory bandwidth, network latency, energy, and failure rates govern a microcontroller with 256 KB of memory and an accelerator in a datacenter alike, even though the two differ in scale by many orders of magnitude. I learned this while working on TinyML at Google, and it became the idea that runs through every volume: constraints drive architecture.

Teaching AI engineering this way takes more than a book, which is why everything lives in one repository. Each part teaches something the others cannot. Students who only read do not internalize, and students who only code do not generalize. The textbook builds the mental model, TinyTorch makes it concrete by having students build the machinery themselves, and the hardware kits and the MLSys·im simulator show where the model breaks, on devices students can hold and at scales beyond any one lab.

The work began in a classroom. The HarvardX TinyML course came first and reached more than 100,000 learners. In 2023, the students in CS249r at Harvard wrote the first class notes for this curriculum together, one topic per group, and we published them on GitHub. Since then, I have kept revising the material with help from a growing community of contributors, and instructors at universities around the world now teach from it. The goal is to reach one million learners by 2030, because the world is building AI factories faster than it is training AI engineers.


What You Will Learn

Each chapter connects an idea a reader may already know from machine learning to the systems that make it work in practice.

You know... You will learn...
How to train a model → How training scales across accelerator clusters
That quantization shrinks models → How low-precision arithmetic maps to silicon
What a transformer is → Why the KV cache dominates memory at inference
Models run on accelerators → How serving systems batch requests to balance latency against throughput
Models need good data → How data pipelines, selection, and drift decide what a model can learn
Models get deployed → How to benchmark, monitor, and roll back models in production
Hardware fails sometimes → How to checkpoint and recover training jobs that span thousands of accelerators
Edge devices have limits → How to co-design models and hardware
AI uses a lot of energy → How to measure and reduce the energy and carbon cost of a system over its full lifecycle
How to prompt an LLM → How to architect agent loops, tool sandboxes, and context memory (Vol III, in development)
How vision and robotics models infer → How to close real-time sensor-actuator loops under physical constraints (Vol IV, in development)

The Four Volumes

The textbook spans four volumes. Each one widens the boundary of the system and raises the cost of failure, so the volumes differ in scope, not in depth.

Volume Unit of work Core systems question Status
📗 I. Introduction to Machine Learning Systems The model How does intelligence execute efficiently on a single machine? Released
Forthcoming in print from MIT Press
📘 II. Scaling Machine Learning Systems The fleet How does intelligence scale across distributed clusters and datacenters? Preview
In active revision
🟣 III. Agentic Machine Learning Systems The trajectory How is intelligence governed when it acts autonomously over long horizons? In development
Changes often
🌲 IV. Physical AI: Machine Learning Systems That Sense and Act The physical action How can intelligence act safely on matter and physical systems? In development
Changes often

Each volume answers a question the previous one leaves open.

  • Vol I → Vol II, when one machine is not enough. Volume I covers single-machine execution, memory walls, and kernel efficiency. Volume II carries those foundations across thousands of accelerators, collective communication, fault-tolerant networks, and datacenter orchestration.
  • Vol II → Vol III, when a stateless response is not enough. Volume II serves stateless requests at scale. Volume III adds stateful, multi-step loops that manage context memory, call tools, run in sandboxes, and recover from nondeterministic failures.
  • Vol III → Vol IV, when software acts on the physical world. Volume III governs software environments. Volume IV crosses into physical systems, where computational latency becomes distance traveled and a failure cannot be undone.

I am writing Volumes III and IV because I plan to teach both subjects, and because they are where machine learning systems are heading. The progression is a natural one. Volumes I and II run in an open loop, where a request goes in and a response comes out. Volume III closes the loop in software, where an agent acts, observes the result, and acts again. Volume IV closes it through the physical world. Writing a book is how I learn a subject well enough to teach it.

⚠️ Volumes III and IV are open drafts. Chapters are added, reorganized, and rewritten as my understanding grows, so please do not cite or teach from them yet. Feedback is welcome through the book feedback issue forms.


What's in the Repository

Around the textbook sit the companion tools that let students build, measure, and practice what they read. The pieces are designed to work together, but none of them requires the others.

Curriculum map showing how the textbook, labs, TinyTorch, hardware kits, MLSys·im, and StaffML connect

Component What it does Status Links
📖 Textbook Four volumes that build the mental models, from one machine to fleets, agents, and physical systems. Vol I released Read online
🔥 Tiny🔥Torch Build an ML framework from scratch in 20 progressive modules, from tensors to a transformer. Released Get started · Repo guide
🔮 MLSys·im Model memory, compute, network, and energy limits for systems too large to run in a classroom. The textbook's calculations are built on it. Released Use simulator · Repo guide
🛠️ Hardware Kits Deploy models to Arduino, Seeed, Grove, and Raspberry Pi devices, with real memory limits, power budgets, and latency. Released Browse kits · Repo guide
🔬 Labs Interactive Marimo notebooks, run in the browser, that pair with textbook chapters. A student predicts an outcome, changes a parameter, and sees what breaks. Early release, built in the open Try labs · Repo guide
💼 StaffML More than 9,000 systems design questions across cloud, edge, mobile, and TinyML, with practice drills and mock interviews. Early release Practice · Repo guide
🎓 Instructor Hub A syllabus for each course, with weekly readings and slides: introductory, scaling, TinyML, Edge AI, Physical AI (draft), and Agentic AI (in preparation). Released View hub · Repo guide
🎬 Lecture Slides Beamer decks for every chapter of the textbook, in one shared theme that is easy to restyle. Released Browse decks · Repo guide
📬 Newsletter Updates on new chapters, releases, and what the community is building. Ongoing Subscribe

Two earlier-stage experiments also live here. SocratiQ is an AI tutor that adds guided reading, quizzes, and spaced repetition to static learning sites. MLPerf EDU is a teaching benchmark suite aligned with MLCommons MLPerf.


Start Here

Where to begin depends on what you want from the curriculum.

If you are... Start here Then go deeper
📖 A student or self-learner Read Volume I Build TinyTorch, model systems with MLSys·im, try the labs (early release), and practice with StaffML
🎓 An instructor Open the Instructor Hub Pick a course and use its syllabus, slides, kits, and labs
🤝 A contributor Find the guide for your component under Contributing Report problems through GitHub Issues

How the Material Is Made

No chapter is written once. Each one goes through a cycle that repeats as the field changes.

  1. Watch the field. I follow the research and industry venues where new work appears: ISCA, MICRO, HPCA, ASPLOS, ISPASS, MLSys, NeurIPS, ICML, ICLR, Hot Chips, and industry summits.
  2. Distill. A chapter keeps the principles and leaves out the variations. Quantization, for example, has been implemented in dozens of ways, and a student needs the principles that explain all of them. To decide what belongs, I use a test that David Patterson, who wrote the foreword to Volume I, gave me. A technique earns a place only when several companies use it in practice. That test ties the material to systems in production, so what a student learns carries over to practice.
  3. Review with practitioners. I review chapters one-on-one with the engineers who build these systems inside large companies, from hyperscale infrastructure engineers to model developers. Practitioners at Arm, Google, Intel, Meta, Microsoft, Qualcomm, STMicroelectronics, and other organizations have reviewed the material, and academic reviewers in Europe, Asia, and the Americas have tested it against their own research and teaching.
  4. Teach it. Volume I has been taught at Harvard through CS249r since 2023 and adopted by instructors at UC Berkeley, Columbia, Georgia Tech, IIT Bombay, and universities across Europe, Latin America, Africa, and Asia. The classroom shows where students get stuck.
  5. Revise. Reader issues, reviewer notes, and classroom experience go back into the next draft.

Reviewers do more than check facts, and sometimes they change what the book covers. Sustainable AI and responsible AI both entered the book this way. Engineers building AI datacenters told me that the footprint of these facilities keeps growing and that students need to learn to account for it. Their concern led to a chapter I had not planned, which I wrote in 2023, before sustainable AI was a common topic.

Engineers in industry also urged me to teach responsible AI. It can look like a subject outside traditional engineering, but the systems in this book make decisions that affect people, and more and more of them act on their own. The engineers who build such systems are responsible for how they behave, so the book teaches that responsibility as part of the engineering.

Readers are part of the review, too. Every chapter is open, and when something is wrong, unclear, or missing, the book feedback forms send it straight into the next revision.

Numbers are computed, not typed. Every derived quantity in the books comes from Python code that ships with the text. I learned the need for this the hard way. In early drafts I typed numbers by hand, made mistakes, and watched the same quantity drift apart from one chapter and one volume to the next. No author can hold every number across the series in mind at once, so I wrote MLSys·im to hold them instead. It is the single source of truth for every chapter and every volume. Each hardware and model specification in it traces to a cited source, and when a value changes there, every chapter that uses it changes with it. A test suite runs on every commit and checks unit consistency, cross-references, notation, and citations.


FAQ

Why do you do all this?

When I began teaching machine learning systems, there was no textbook for the course. Books covered the models, and papers covered individual systems, but nothing taught the infrastructure underneath them as one subject. The field was changing too quickly for anyone to have written one. So I started writing it myself, because I have always learned best by building from scratch and teaching others.

When I want to understand an emerging or complex systems area, writing about it and writing code for it force me to slow down. They force me to find the principles that last, work through the math, and separate what is fundamentally true about physics and hardware from what is merely current.

This repository is my open workshop and teaching lab. It is where I work out ideas for my students at Harvard, my research lab, and open benchmarking efforts like MLPerf. Volumes III and IV are that process happening in public.

There is also a deeper reason. In the late 1990s, as an undergraduate, I wrote to a professor at Stanford because I was fascinated by genetic algorithms. I did not expect an answer. Then a brown package arrived at my house with a VHS tape on genetic algorithms inside, sent from the professor's office. I no longer remember the professor's name, so I never got to say thank you, but I have not forgotten what it felt like to have someone I had never met take the time to share what they knew with a curious student. That package sparked my curiosity, and the feeling has stayed with me.

Students write to me now the way I once wrote to that professor, far more than I can answer one by one. This curriculum is my way of sending the package back out, to a much bigger classroom than any lecture hall can hold.

Who is this for, and what should I know first?

It is for anyone who wants to understand how intelligent systems run, not only how models are trained: students, software engineers moving into ML infrastructure, hardware architects, and educators designing courses.

The only assumptions are that the reader can program in Python and has met basic machine learning ideas, such as a neural network or a loss function. The systems concepts are built from the ground up. No prior background in computer architecture, networking, or distributed systems is needed.

Do I need Volume I before Volume II?

No. The two volumes differ in scope, not in depth or rigor.

Volume I covers one machine with a handful of accelerators, from the memory hierarchy and kernel efficiency to quantization and on-device deployment. Volume II covers the fleet, with thousands of accelerators connected by high-speed networks, the parallelism that spans them, fault tolerance, and serving at datacenter scale.

Volume II does not assume that a reader has finished Volume I, so a reader with strong single-machine foundations can start there. Reading Volume I first gives the cleanest mental model from the silicon up, in the same way that Hennessy and Patterson's Computer Organization and Design precedes Computer Architecture: A Quantitative Approach.

Do I need TinyTorch, the labs, and the kits, or can I just read the book?

Each volume stands on its own as a textbook. The companions are there for readers who want to go further. Reading builds the mental model, and building and measuring make it last. Start with the book and add the hands-on pieces when an idea needs to become practice.

Isn't this just a deep learning book?

Books such as Goodfellow, Bengio, and Courville's Deep Learning, Bishop's texts, d2l.ai, and fast.ai teach the mathematics, architectures, and optimization of models, and they teach them well.

This curriculum starts where those books stop. It treats the model as one component inside a system that must ingest data, run on real silicon under power and thermal limits, answer queries within milliseconds, and keep running across thousands of machines. A reader can finish an excellent deep learning course and still not know why a cluster idles at 30% utilization, why serving memory grows with the KV cache, or how gradients are synchronized without stalling the network. Those questions are the subject here.

Isn't this MLOps, or the same as Designing Machine Learning Systems?

MLOps books, such as Chip Huyen's Designing Machine Learning Systems, focus on operational pipelines: feature stores, workflow orchestration, and deployment with current industry tools. They are valuable practical guides.

This curriculum focuses on what lies underneath: the hardware limits, quantitative trade-offs, and first principles that explain why those tools are designed as they are, and the limits no tool escapes, such as memory bandwidth, network latency, energy, and failure rates.

The two differ the way a recipe differs from an understanding of how heat, salt, fat, and time interact. A recipe works until the oven changes or the batch grows tenfold. Understanding the chemistry lets a cook work in any kitchen, fix a dish that went wrong, and invent new ones.

How is this different from The Datacenter as a Warehouse-Scale Computer?

Barroso, Hölzle, and Clidaras give a firsthand account of how one organization built hyperscale infrastructure, and I admire that work. This curriculum aims to complement it in three ways:

  1. A progressive curriculum, not a reference. It starts from a single machine and its memory hierarchy (Volume I) and builds up to multi-node clusters and warehouse-scale fleets (Volume II), with quantitative exercises along the way.
  2. Vendor-neutral foundations. It generalizes across accelerator architectures (GPUs, TPUs, custom ASICs) and deployment targets (cloud clusters to milliwatt microcontrollers), so the principles carry across hardware generations.
  3. Hands-on and living. The text is surrounded by code readers build themselves (TinyTorch), open hardware kits, cluster modeling (MLSys·im), and community contributions, and it changes as the field does.
Do you use AI tools?

Yes, and I would rather say so plainly than leave readers to guess. I use generative AI tools to write code and the checks that test it, to survey the literature before I read the papers myself, to draft passages that I then rewrite, to help produce figures that I once drew by hand, and to audit the books for consistency. I use them on the companions as well, from TinyTorch and the labs to the slides and the StaffML question bank. They are also how I learn a new area quickly. The tools take on mechanical work, which leaves my time for the parts that need a teacher: what to include, how to explain it, and whether it is right.

A tool can write text that sounds right and is wrong, so I do not take its output on trust. I check the work in ways that do not depend on the tool. Every number in the books is computed by code, and automated checks run whenever something changes. Practitioners review the chapters, and students test them in class. In StaffML, each question records whether it began as a machine draft and whether a person has reviewed it.

I researched, wrote, and rewrote every chapter. The decisions about what goes in, what stays out, and how an idea is taught are mine, and so is every mistake. Because all of the work is open, anyone can check it and tell me what they find.

Volumes III and IV have not yet been through the classroom or practitioner review, which is why they are marked as drafts. Each volume includes a full Note on AI Assistance.

Why read a textbook in the age of LLMs?

Language models are good at retrieval, code generation, and summarizing facts. A paragraph that only delivers a fact a reader could look up in seconds has not earned its place in a textbook.

What a textbook provides is perspective and a coherent mental model: the order in which to learn ideas, how trade-offs constrain one another, and what not to worry about. Deciding what to leave out is one of the most important choices an author makes.

Bruce Davie made this point in his essay “Textbooks in Tokenland” (Systems Approach). A language model generates text without communicative intent, he writes, while a textbook is a deliberate path from a teacher to a student toward a shared understanding of how the world works.

The two are not in opposition. The book provides the structure and the quantitative argument, and interactive tools let a reader test that understanding. The Marimo labs ask a reader to predict an outcome and then check it, and the SocratiQ tutor answers questions about the page being read.

Is it free, and how do I read it?

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

The textbook is released under a Creative Commons license (CC BY-NC-ND 4.0), the same license as the MIT Press print edition. It may be read and shared for non-commercial use with attribution. Translations and other modified versions need permission. The companion software is open source under its own licenses, listed under License.


Support This Work

If this curriculum has helped you, there are two simple ways to help it grow.

GitHub stars    Open Collective

Star the repository
A star takes one click, and each one tells universities, foundations, and other learners that people want to study how machine learning systems are built. That helps AI engineering earn its place in the curriculum, and the support of those institutions pays for workshops and hardware kits in classrooms that could not otherwise afford them.

Stars matter to me as well. This is a long project, and the new stars I see each morning are what keep me going, because each one tells me that a student somewhere is learning from this work.

Star History Chart
Fund the work
Contributions go to Open Collective, a transparent fund for educational outreach where every expense is public. The money goes back into the work, to reach more students and to improve the material they learn from.

Open Collective

Contributing

Area What you can do Where to start
📖 Textbook Fix an error, clarify an explanation, or suggest material for any chapter. Textbook guide
🔥 TinyTorch Add a module, fix a bug, or improve the tests and documentation. TinyTorch guide
🛠️ Hardware Kits Improve the deployment guides, examples, and board support. Kits guide
🔬 Labs and MLSys·im Improve the interactive labs or the simulator's hardware and model data. Labs guide · MLSys·im guide
💼 StaffML Improve the systems design questions, answers, and interview practice. StaffML guide
🧠 SocratiQ Improve the tutor, its quizzes, and its prompts. SocratiQ guide
🐛 Report an issue Point out an error, a broken link, or anything unclear. GitHub Issues
💬 Ask a question Ask about the material or share what you are building with it. GitHub Discussions

Branches. Development happens on dev, which this page shows. The main branch holds what is live on mlsysbook.ai, and the publish workflow promotes dev to main at each release.


License

This is a multi-component repository, and each component is released under its own license to match its purpose. The license file inside each directory, such as tinytorch/LICENSE or staffml/app/LICENSE, is authoritative.

Component License What it means
📖 Textbook
books/
CC BY-NC-ND 4.0 The license of the MIT Press edition. Share for non-commercial use with attribution. Modified versions, including translations, need permission.
🧰 Labs, Kits, Slides, Instructor Hub
labs/ · kits/ · slides/ · instructors/
CC BY-NC-SA 4.0 Share and adapt for non-commercial use, with attribution and same-license sharing.
🔥 TinyTorch MIT Permissive. Use, modify, and redistribute, including commercially.
🔮 MLSys·im Apache 2.0 Permissive with explicit patent grant.
💼 StaffML AGPL v3 Strong copyleft. Modifications to deployed services must be published. Commercial licenses are available from the authors.
🗃️ StaffML question corpus CC BY-NC 4.0 Research and educational use. Commercial use requires permission.
🔢 TinyDigits dataset BSD 3-Clause Permissive (matches sklearn ancestry).
🗣️ TinyTalks dataset CC BY 4.0 Permissive with attribution. Commercial use is allowed.

A shorter summary for readers is at mlsysbook.ai/about/license.

If you are an institution considering adoption, or a company interested in commercial terms for a copyleft component, please write to [email protected].


Acknowledgments

I assembled this curriculum, but I did not invent most of what it teaches. The ideas come from the engineers and practitioners in industry who build these systems every day, and from researchers worldwide who study them and publish what they learn. The books cite their work throughout, and the curriculum would not exist without it. My own research lab has contributed as well.

Many people also gave their time to the curriculum itself. My students in CS249r at Harvard have tested every revision. Reviewers in industry and academia read chapters and told me where I was wrong. Instructors who adopted the material reported what worked in their classrooms and what did not. Readers found errors, and contributors fixed them. The financial contributors on Open Collective helped carry the work to more students.

Whatever is good here owes a great deal to all of them. The mistakes are mine.


Contributors

These people have improved the textbooks, the software, and the teaching materials.

Legend: 🪲 Bug Hunter · 🧑‍💻 Code Contributor · ✍️ Doc Wizard · 🎨 Design Artist · 🧠 Idea Spark · 🔎 Code Reviewer · 🧪 Test Tinkerer · 🛠️ Tool Builder

📖 Textbook Contributors

Vijay Janapa Reddi
Vijay Janapa Reddi

🪲 🧑‍💻 🎨 ✍️ 🧠 🔎 🧪 🛠️
Zeljko Hrcek
Zeljko Hrcek

🪲 🧑‍💻 🎨 ✍️ 🛠️
Rocky
Rocky

🪲 🧑‍💻 🎨 ✍️
Farhan Asghar
Farhan Asghar

🪲 🧑‍💻 🎨 ✍️
Marcelo Rovai
Marcelo Rovai

🧑‍💻 🎨 🧪
Gabriel Amazonas
Gabriel Amazonas

🪲 ✍️ 🧠
Octopus
Octopus

🪲 🧑‍💻 ✍️
Tess Watt
Tess Watt

🪲 ✍️
Jahnic Beck
Jahnic Beck

🪲 ✍️
bluebaer
bluebaer

🪲 ✍️
Kai Kleinbard
Kai Kleinbard

🧑‍💻 🛠️
Didier Durand
Didier Durand

✍️ 🪲
Salman Chishti
Salman Chishti

🧑‍💻 ✍️
GronuJ
GronuJ

🪲 ✍️
Gustaf Hammarberg
Gustaf Hammarberg

🪲 🧑‍💻
Aayush Kumar
Aayush Kumar

🪲 🧑‍💻
Yue Cheng
Yue Cheng

🪲 🧑‍💻
s3rg3ysh
s3rg3ysh

🪲 ✍️
Johnson K C
Johnson K C

🧑‍💻 🛠️
mehdi B
mehdi B

🪲 🧑‍💻
Shivtej Gaikwad
Shivtej Gaikwad

🪲 🧑‍💻
Jason Jabbour
Jason Jabbour

✍️
Ikechukwu Uchendu
Ikechukwu Uchendu

✍️
Naeem Khoshnevis
Naeem Khoshnevis

✍️
Sara Khosravi
Sara Khosravi

✍️
Douwe den Blanken
Douwe den Blanken

✍️
Jeffrey Ma
Jeffrey Ma

✍️
shanzehbatool
shanzehbatool

✍️
Elias
Elias

✍️
Jared Ping
Jared Ping

✍️
Itai Shapira
Itai Shapira

✍️
Maximilian Lam
Maximilian Lam

✍️
Jayson Lin
Jayson Lin

✍️
Sophia Cho
Sophia Cho

✍️
Andrea
Andrea

✍️
Alex Rodriguez
Alex Rodriguez

✍️
Korneel Van den Berghe
Korneel Van den Berghe

✍️
Nimo
Nimo

✍️
Colby Banbury
Colby Banbury

✍️
Zishen Wan
Zishen Wan

✍️
Mark Mazumder
Mark Mazumder

✍️
Abdulrahman Mahmoud
Abdulrahman Mahmoud

✍️
Divya Amirtharaj
Divya Amirtharaj

✍️
Srivatsan Krishnan
Srivatsan Krishnan

✍️
marin-llobet
marin-llobet

✍️
Aghyad Deeb
Aghyad Deeb

✍️
Haoran Qiu
Haoran Qiu

✍️
Emil Njor
Emil Njor

✍️
ELSuitorHarvard
ELSuitorHarvard

✍️
kaiM0ves
kaiM0ves

✍️
oishib
oishib

✍️
Jared Ni
Jared Ni

✍️
Aditi Raju
Aditi Raju

✍️
Michael Schnebly
Michael Schnebly

✍️
Thuong Duong
Thuong Duong

✍️
Yu-Shun Hsiao
Yu-Shun Hsiao

✍️
Henry Bae
Henry Bae

✍️
Eimhin Laverty
Eimhin Laverty

✍️
Jae-Won Chung
Jae-Won Chung

✍️
Shvetank Prakash
Shvetank Prakash

✍️
Marco Zennaro
Marco Zennaro

✍️
Arya Tschand
Arya Tschand

✍️
Andrew Bass
Andrew Bass

✍️
Pong Trairatvorakul
Pong Trairatvorakul

✍️
Eura Nofshin
Eura Nofshin

✍️
Matthew Stewart
Matthew Stewart

✍️
Emeka Ezike
Emeka Ezike

✍️
jianqingdu
jianqingdu

✍️
Jennifer Zhou
Jennifer Zhou

✍️
The Random DIY
The Random DIY

✍️
Fatima Shah
Fatima Shah

✍️
Bruno Scaglione
Bruno Scaglione

✍️
Allen-Kuang
Allen-Kuang

✍️
Tauno Erik
Tauno Erik

✍️
gnodipac886
gnodipac886

✍️
Sercan Aygün
Sercan Aygün

✍️
TheHiddenLayer
TheHiddenLayer

✍️
Gauri Jain
Gauri Jain

✍️
Fin Amin
Fin Amin

✍️
Alex Oesterling
Alex Oesterling

✍️
Abenezer Angamo
Abenezer Angamo

✍️
Baldassarre Cesarano
Baldassarre Cesarano

✍️
अरनव शुक्ला | Arnav Shukla
अरनव शुक्ला | Arnav Shukla

✍️
Rin
Rin

✍️
Bilge Acun
Bilge Acun

✍️
Andy Cheng
Andy Cheng

✍️
Aritra Ghosh
Aritra Ghosh

✍️
abigailswallow
abigailswallow

✍️
Yang Zhou
Yang Zhou

✍️
JEON HYUNJUN(Luciano)
JEON HYUNJUN(Luciano)

✍️
Emmanuel Rassou
Emmanuel Rassou

✍️
Jason Yik
Jason Yik

✍️
Jessica Quaye
Jessica Quaye

✍️
Cursor Agent
Cursor Agent

✍️
happyappledog
happyappledog

✍️
Snuggs
Snuggs

✍️
Sam Wilcock
Sam Wilcock

✍️
Shreya Johri
Shreya Johri

✍️
Sonia Murthy
Sonia Murthy

✍️
Costin-Andrei Oncescu
Costin-Andrei Oncescu

✍️
formlsysbookissue
formlsysbookissue

✍️
Annie Laurie Cook
Annie Laurie Cook

✍️
Parampreet Singh
Parampreet Singh

✍️
Vijay Edupuganti
Vijay Edupuganti

✍️
Jothi Ramaswamy
Jothi Ramaswamy

✍️
Batur Arslan
Batur Arslan

✍️
<

(README truncated)

Recent activity

commits and pull requests

Recent open issues

view all

Discussions

all 71

Releases and announcements

40 total
  1. vol2-v0.3.1: Publish SocratiQ and Volume II updatesvol2-v0.3.1Nov 6, 202646 downloads

    Volume II 0.3.1 restores SocratiQ in the online book and updates the text, figures, and printed layout. - Select a passage for an explanation, ask follow-up questions, and open quizzes or flashcards alongside the reading. A skippable first-use tour and optional learning preferences explain and adjust the workflow. - The updated SocratiQ guide explains keyboard and touch controls, browser-local study records, and the passage and preferences sent for AI help. Reader conversations remain in page memory. - Chapter revisions improve paragraph flow and connections between systems topics. The reference training job now uses a shared step definition; figure, equation, and appendix changes address presentation and printed-page fit. PDF and EPUB editions are attached. AI explanations and quiz feedback can be mistaken; they are study aids, not evidence of mastery.

  2. vol1-v0.8.1: Publish SocratiQ and Volume I updatesvol1-v0.8.1Nov 6, 202682 downloads

    Volume I 0.8.1 restores SocratiQ in the online book and updates the text, figures, and printed layout. - Select a passage for an explanation, ask follow-up questions, and open quizzes or flashcards alongside the reading. A skippable first-use tour and optional learning preferences explain and adjust the workflow. - The updated SocratiQ guide explains keyboard and touch controls, browser-local study records, and the passage and preferences sent for AI help. Reader conversations remain in page memory. - Chapter revisions clarify scope and narrative connections, qualify overstated claims, and move derived values into rerunnable calculations. Figure and equation changes address presentation and printed-page fit. PDF and EPUB editions are attached. AI explanations and quiz feedback can be mistaken; they are study aids, not evidence of mastery.

  3. TinyTorch 0.2.2 updates teaching exercises and the Module 01 broadcasting explanation. - Use a high-resolution interval clock in activation and data-loader timing exercises, avoiding zero-duration wall-clock readings on short runs such as those reported on Windows. - Report nonpositive intervals as unmeasurable instead of dividing by zero when calculating timing comparisons. - Clarify vector broadcasting and organize the example headings. Site: https://mlsysbook.ai/tinytorch/ These timing changes affect the exercises; they do not establish a framework speedup or benchmark result.

  4. StaffML 0.1.4 updates the question vault, taxonomy navigation, and service source. - Correct hardware assumptions and worked reasoning in questions about mobile memory bandwidth, batch-one decoding weight reads, and edge-device rooflines. - Update taxonomy labels and relationships, preserve subject/concept filtering in practice links, and revise vault authoring/schema checks. - Replace provider response bodies and arbitrary exceptions in interviewer diagnostics with bounded error codes and HTTP statuses. - Harden analytics origin checks, submitted-event validation, aggregate key handling, and summary authorization; document service and storage boundaries. Site: https://mlsysbook.ai/staffml/ This release includes service-source changes; a site release does not by itself establish deployment of every Worker. Analytics filtering does not guarantee that submitted data contains no personal information.

  5. Slides 0.1.1 updates the lecture materials and portal for Volumes I and II. - Rebuild and revise decks around the book's chapter sequence, with selected Volume I topics split into paired lectures. - Revise figures, typography, speaker notes, activities, and lecture-to-lecture connections; connect calculated examples to shared modeling inputs and retain source-specific assumptions. - Add mechanical checks for deck structure and visual fit, improve chapter-to-slide links, and carry speaker notes into PowerPoint exports. The live portal and MLSysBook slide archives include Volumes I and II only. Volume III and Volume IV decks remain outside this live release. PowerPoint slides are images of PDF pages, with speaker notes in the notes pane; slide text is not editable. Portal: https://mlsysbook.ai/slides/ PDF and PowerPoint downloads: https://github.com/harvard-edge/cs249r_book/releases/tag/slides-latest

Commits per week

last 52 weeks
11390Week of 2025-11-16: 6 commitsWeek of 2025-11-23: 22 commitsWeek of 2025-11-30: 108 commitsWeek of 2025-12-07: 239 commitsWeek of 2025-12-14: 197 commitsWeek of 2025-12-21: 48 commitsWeek of 2025-12-28: 177 commitsWeek of 2026-01-04: 215 commitsWeek of 2026-01-11: 152 commitsWeek of 2026-01-18: 287 commitsWeek of 2026-01-25: 329 commitsWeek of 2026-02-01: 228 commitsWeek of 2026-02-08: 103 commitsWeek of 2026-02-15: 110 commitsWeek of 2026-02-22: 135 commitsWeek of 2026-03-01: 168 commitsWeek of 2026-03-08: 113 commitsWeek of 2026-03-15: 276 commitsWeek of 2026-03-22: 199 commitsWeek of 2026-03-29: 283 commitsWeek of 2026-04-05: 284 commitsWeek of 2026-04-12: 444 commitsWeek of 2026-04-19: 1060 commitsWeek of 2026-04-26: 476 commitsWeek of 2026-05-03: 761 commitsWeek of 2026-05-10: 613 commitsWeek of 2026-05-17: 639 commitsWeek of 2026-05-24: 800 commitsWeek of 2026-05-31: 1139 commitsWeek of 2026-06-07: 641 commitsWeek of 2026-06-14: 270 commitsWeek of 2026-06-21: 173 commitsWeek of 2026-06-28: 89 commitsWeek of 2026-07-05: 70 commitsWeek of 2026-07-12: 135 commitsWeek of 2026-07-19: 11 commitsWeek of 2026-07-26: 24 commitsWeek of 2026-08-02: 231 commitsWeek of 2026-08-09: 436 commitsWeek of 2026-08-16: 237 commitsWeek of 2026-08-23: 361 commitsWeek of 2026-08-30: 452 commitsWeek of 2026-09-06: 701 commitsWeek of 2026-09-13: 728 commitsWeek of 2026-09-20: 522 commitsWeek of 2026-09-27: 565 commitsWeek of 2026-10-04: 537 commitsWeek of 2026-10-11: 782 commitsWeek of 2026-10-18: 866 commitsWeek of 2026-10-25: 317 commitsWeek of 2026-11-01: 330 commitsWeek of 2026-11-08: 16 commitsNov 16, 2025Nov 8, 2026
18.1K commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 22 commitsSun 1:00 — 25 commitsSun 2:00 — 39 commitsSun 3:00 — 13 commitsSun 4:00 — 18 commitsSun 5:00 — 22 commitsSun 6:00 — 35 commitsSun 7:00 — 46 commitsSun 8:00 — 106 commitsSun 9:00 — 188 commitsSun 10:00 — 185 commitsSun 11:00 — 181 commitsSun 12:00 — 139 commitsSun 13:00 — 134 commitsSun 14:00 — 201 commitsSun 15:00 — 261 commitsSun 16:00 — 130 commitsSun 17:00 — 136 commitsSun 18:00 — 190 commitsSun 19:00 — 150 commitsSun 20:00 — 100 commitsSun 21:00 — 71 commitsSun 22:00 — 88 commitsSun 23:00 — 34 commitsMon 0:00 — 62 commitsMon 1:00 — 26 commitsMon 2:00 — 51 commitsMon 3:00 — 43 commitsMon 4:00 — 59 commitsMon 5:00 — 95 commitsMon 6:00 — 37 commitsMon 7:00 — 94 commitsMon 8:00 — 113 commitsMon 9:00 — 127 commitsMon 10:00 — 170 commitsMon 11:00 — 184 commitsMon 12:00 — 166 commitsMon 13:00 — 274 commitsMon 14:00 — 160 commitsMon 15:00 — 212 commitsMon 16:00 — 262 commitsMon 17:00 — 205 commitsMon 18:00 — 200 commitsMon 19:00 — 245 commitsMon 20:00 — 254 commitsMon 21:00 — 161 commitsMon 22:00 — 147 commitsMon 23:00 — 94 commitsTue 0:00 — 120 commitsTue 1:00 — 69 commitsTue 2:00 — 44 commitsTue 3:00 — 18 commitsTue 4:00 — 8 commitsTue 5:00 — 23 commitsTue 6:00 — 67 commitsTue 7:00 — 155 commitsTue 8:00 — 206 commitsTue 9:00 — 104 commitsTue 10:00 — 176 commitsTue 11:00 — 199 commitsTue 12:00 — 115 commitsTue 13:00 — 160 commitsTue 14:00 — 198 commitsTue 15:00 — 162 commitsTue 16:00 — 143 commitsTue 17:00 — 193 commitsTue 18:00 — 206 commitsTue 19:00 — 192 commitsTue 20:00 — 186 commitsTue 21:00 — 155 commitsTue 22:00 — 130 commitsTue 23:00 — 155 commitsWed 0:00 — 93 commitsWed 1:00 — 55 commitsWed 2:00 — 43 commitsWed 3:00 — 23 commitsWed 4:00 — 24 commitsWed 5:00 — 21 commitsWed 6:00 — 38 commitsWed 7:00 — 112 commitsWed 8:00 — 124 commitsWed 9:00 — 121 commitsWed 10:00 — 130 commitsWed 11:00 — 134 commitsWed 12:00 — 153 commitsWed 13:00 — 178 commitsWed 14:00 — 228 commitsWed 15:00 — 235 commitsWed 16:00 — 210 commitsWed 17:00 — 211 commitsWed 18:00 — 204 commitsWed 19:00 — 165 commitsWed 20:00 — 106 commitsWed 21:00 — 108 commitsWed 22:00 — 86 commitsWed 23:00 — 71 commitsThu 0:00 — 90 commitsThu 1:00 — 49 commitsThu 2:00 — 19 commitsThu 3:00 — 32 commitsThu 4:00 — 51 commitsThu 5:00 — 54 commitsThu 6:00 — 46 commitsThu 7:00 — 113 commitsThu 8:00 — 179 commitsThu 9:00 — 140 commitsThu 10:00 — 206 commitsThu 11:00 — 159 commitsThu 12:00 — 166 commitsThu 13:00 — 228 commitsThu 14:00 — 227 commitsThu 15:00 — 179 commitsThu 16:00 — 147 commitsThu 17:00 — 223 commitsThu 18:00 — 200 commitsThu 19:00 — 154 commitsThu 20:00 — 141 commitsThu 21:00 — 108 commitsThu 22:00 — 75 commitsThu 23:00 — 124 commitsFri 0:00 — 55 commitsFri 1:00 — 33 commitsFri 2:00 — 21 commitsFri 3:00 — 17 commitsFri 4:00 — 30 commitsFri 5:00 — 11 commitsFri 6:00 — 36 commitsFri 7:00 — 93 commitsFri 8:00 — 129 commitsFri 9:00 — 154 commitsFri 10:00 — 158 commitsFri 11:00 — 136 commitsFri 12:00 — 155 commitsFri 13:00 — 139 commitsFri 14:00 — 182 commitsFri 15:00 — 176 commitsFri 16:00 — 105 commitsFri 17:00 — 138 commitsFri 18:00 — 191 commitsFri 19:00 — 155 commitsFri 20:00 — 90 commitsFri 21:00 — 78 commitsFri 22:00 — 63 commitsFri 23:00 — 95 commitsSat 0:00 — 67 commitsSat 1:00 — 99 commitsSat 2:00 — 25 commitsSat 3:00 — 22 commitsSat 4:00 — 9 commitsSat 5:00 — 26 commitsSat 6:00 — 43 commitsSat 7:00 — 52 commitsSat 8:00 — 129 commitsSat 9:00 — 155 commitsSat 10:00 — 141 commitsSat 11:00 — 145 commitsSat 12:00 — 172 commitsSat 13:00 — 131 commitsSat 14:00 — 161 commitsSat 15:00 — 159 commitsSat 16:00 — 188 commitsSat 17:00 — 167 commitsSat 18:00 — 125 commitsSat 19:00 — 109 commitsSat 20:00 — 77 commitsSat 21:00 — 118 commitsSat 22:00 — 72 commitsSat 23:00 — 46 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.
DateListRankStars gained
Jul 3, 2026daily#25+9
Feb 20, 2026daily#25+108
Feb 19, 2026daily#15+154
Feb 18, 2026daily#16+181
Feb 17, 2026daily#21+143