OpenMLSys: A Chinese-Language Textbook on the Machine Learning Systems Stack

The gap OpenMLSys targets: systems knowledge between the model and the hardware

Most machine learning material stops at the model. You get gradient descent, loss functions, and a framework call that hides everything else. OpenMLSys addresses the layer in between: how tensors are represented, how automatic differentiation is implemented, how a graph is lowered through an intermediate representation, how an accelerator executes it, and how a job is spread across many devices. The README states the project explains the design principles and implementation experience of modern machine learning systems, covering the full stack from programming interfaces and computation graphs through compilers to distributed training.

The intended audience is stated explicitly and narrowly. Students who already have machine learning theory and want to go deeper into systems design. Researchers who need to write custom operators or use distributed execution for large models. Engineers responsible for machine learning infrastructure who need to tune and customize at a low level. Someone looking for an introduction to machine learning itself is not the target reader, and the book does not pretend otherwise.

The second edition is organized into nine chapters, listed in the README with links into v2/zh_chapters: introduction, programming interfaces and computation graphs, AI accelerators and programming, AI compilers and runtime systems, data processing systems, training systems, model serving, reinforcement learning systems, and large-scale GPU cluster management. That ordering follows the path a training job actually takes, from tensor abstraction down to cluster scheduling.

How the book is assembled: TeX and Markdown under an mdBook build

The repository reports TeX as its primary language, but the build instructions point at mdBook, a Rust-based static site generator. The two facts sit together rather than contradicting each other: the prose lives in chapter directories under v2/zh_chapters, and the toolchain that renders it to HTML is mdBook. The repository layout in the README shows one directory per chapter, named with a numeric prefix and a descriptive suffix, for example 04_chapter_compiler_and_runtime and 09_chapter_gpu_cluster.

The build script is build_mdbook_v2.sh, invoked with sh. According to the README, it produces two output trees: the English edition under .mdbook-v2/book and the Chinese edition under .mdbook-v2-zh/book. The changelog entry for 2026-03 describes this as a restructuring of the bilingual build architecture and the start of the English edition, so the dual-output layout is recent rather than long-standing. Anyone who worked with an earlier checkout will find the directory names different.

There is no runtime component. Nothing in the README describes a library, a service, or an installable package. The artifact this project produces is HTML you read in a browser or serve yourself. That matters for how you evaluate it: the relevant questions are whether the explanations hold up and whether the build reproduces, not throughput or API stability.

Getting a local build running

The README lists three environment dependencies: curl, git and Python 3. The Rust toolchain is not listed as a prerequisite because the instructions install it. The sequence given is to clone the repository, change into it, install Rust through the rustup script fetched over curl, and then install mdBook with cargo:

git clone https://github.com/openmlsys/openmlsys-zh.git cd openmlsys-zh curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh cargo install mdbook sh build_mdbook_v2.sh

Note the clone URL. The README instructs cloning openmlsys-zh, while the repository under review is openmlsys/openmlsys. The README also links to openmlsys-zh throughout, including in the CI badge, the licence badge and the BibTeX note. Treat the -zh name as the canonical source the documentation was written against, and confirm which remote your checkout actually points at before filing a build problem.

The build script is the only entry point documented, and it takes no arguments in the example. There is no documented flag for building a single chapter or a single language, so a full build is what you get. The README points to CONTRIBUTING/info_zh.md for more detail, which is where you would look if the script fails on your machine. Two contributor-facing files are also named: CONTRIBUTING/style_zh.md for writing style and CONTRIBUTING/terminology.md for the Chinese-English term mapping. If you plan to submit a chapter or a correction, those two files govern whether the pull request is reviewable, and the terminology file exists precisely because the bilingual build makes inconsistent term translation visible.

Where OpenMLSys is the wrong tool

The project is a book. If you arrived looking for something to import, there is nothing to import. No package name appears in the README, no release has been published, and the only build artifact is a directory of HTML. A team that needs a computation graph library, a compiler, or a distributed training runtime will not find it here, and the repository does not claim they will.

The language situation is the second constraint. The primary language is TeX, the online edition linked in the README is the Chinese one at openmlsys.github.io/v1/cn/, and the changelog dates the English edition to 2026-03. A reader who needs English is therefore working with material that is newer and less settled than the Chinese text, and the README does not state how far the English translation has progressed. The chapter table links point into v2/zh_chapters, which are Chinese paths. Do not assume an English reader gets the same depth per chapter.

The version split is the third. The homepage URL carries a v1 segment while the build script and chapter directories are named v2, and the description notes that V2 is launching soon. Chapters may exist in one tree and not the other. If you cite the book, cite the edition, because the two are not interchangeable and the README does not provide a mapping between them.

Finally, the licence. The README states the project uses the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International licence. The repository metadata supplied here lists the licence as unknown, so the README is the only statement available. NonCommercial and ShareAlike are restrictions that matter if you intend to reuse the text in a course, a paid product, or a modified derivative. That is a question for whoever handles licensing where you work, not something this review can settle.

How it compares with Dive into Deep Learning

The natural comparison is Dive into Deep Learning, the other well-known open book in this space. The difference is where each one starts. Dive into Deep Learning begins at the model and teaches the mathematics and the framework calls that produce a working network, with runnable notebooks as the primary vehicle. OpenMLSys begins below the framework and asks what the framework is doing: the README's chapter list runs from tensor abstraction and automatic differentiation through IR design and operator generation to GPU scheduling.

That difference has practical consequences. A reader who wants to train a model on their own data will find OpenMLSys slow going, because it explains the machinery rather than the workflow. A reader who wants to understand why a graph optimization pass changes their kernel selection, or how a distributed training job maps onto a GPU cluster, will find the model-first books silent on exactly those questions. The two are complements, and the README's own audience description, students who have mastered machine learning fundamentals, implicitly assumes the reader has already been through something like the model-first material.

A second difference is the artifact. Dive into Deep Learning ships executable code alongside the prose. OpenMLSys, as described in its README, ships an mdBook build. The book explains systems; it does not hand you a system to run.

Maintenance cost and what the project asks of contributors

For a reader, the maintenance cost is zero, because there is nothing installed to upgrade. You rebuild the HTML when you want a newer copy, and the rebuild command is the same one from the README. The cost that does exist is version drift. The changelog shows the project has moved through several states: initialization in 2022-01, completion of the extended chapters covering federated learning, reinforcement learning and explainable AI in 2022-05, adaptation to MindSpore 2.0 in 2023-05, and the bilingual restructuring in 2026-03. Each of those is a point at which an older checkout diverges from the current text. The MindSpore entry in particular signals that at least some chapters are tied to a specific framework version, so an example that no longer matches current MindSpore behaviour is a plausible failure mode.

For a contributor, the cost is the review process. The README directs contributors to read the style guide and the terminology mapping before submitting, and it maintains a separate contribution document. The bilingual build means a change to a Chinese chapter may create work for the English edition, which is the usual tax on translated technical writing. The project also runs CI, indicated by the workflow badge in the README, though what that workflow checks is not described in the material available here.

There is no release history to track, so there is no changelog of breaking changes to watch. The changelog in the README is a project history, not a version log, and it is the only dated record supplied.

Reading list, not dependency list

The honest framing is that OpenMLSys belongs in a reading list. It gives a structured path through the layers that framework documentation tends to skip, and the nine-chapter v2 table is a reasonable syllabus for a course or a self-study plan. The chapter on compilers and runtime systems and the chapter on large-scale GPU cluster management cover ground that is genuinely hard to find assembled in one place in Chinese.

The friction points are all about state. The build script targets v2 while the linked online edition is v1. The clone URL in the README names openmlsys-zh while the repository is openmlsys/openmlsys. The English edition started in 2026-03 and its completeness is not stated. None of these are faults in the writing, but each one will cost you time if you discover it after you have started. Read the README's build section before you clone, and check which tree your checkout contains before you cite a chapter.

Editorial conclusion

Adopt OpenMLSys as reading material if you are a student who already has machine learning fundamentals and wants the systems layer underneath, or an engineer who needs vocabulary for computation graphs, IR design and distributed training before touching a framework's source. Do not treat it as a dependency: there is no package to install, no API to call, and the CC BY-NC-SA 4.0 licence rules out commercial reuse of the text without checking the terms yourself. Before relying on it as a reference, verify which edition a given chapter belongs to, since the repository now builds both v1 and v2 and the chapter list above describes v2.

Official sources

1. Issues
2. openmlsys/openmlsys on GitHub
3. Project website
4. README