# rCore-Tutorial-Book-v3: Building and Reading the Rust OS Book > rCore-Tutorial-Book-v3 is a Chinese-language book and Sphinx project about writing operating-system kernels in Rust. It suits readers studying the rCore approach, while its repository mainly documents how to build the book rather than providing a turnkey kernel application. **rcore-os/rCore-Tutorial-Book-v3** — A book about how to write OS kernels in Rust easily. - Repository: https://github.com/rcore-os/rCore-Tutorial-Book-v3 - Website: https://rcore-os.cn/rCore-Tutorial-Book-v3/ - Stars: 1,392 · Forks: 263 - Language: Python - License: GPL-3.0 - Published: 2026-10-16 · Updated: 2026-10-16 · Language: en - Canonical page: https://hysenlabs.com/projects/rcore-os-rcore-tutorial-book-v3 ## What rCore-Tutorial-Book-v3 Teaches OS Learners rCore-Tutorial-Book-v3 addresses readers who want to learn how to write operating-system kernels in Rust. Its repository description names that task directly, and its topics identify the associated rCore, Rust, RISC-V, and K210 context. The book is documentation in Chinese, which narrows its immediate audience to readers who can follow that language. It is not presented as a generic Rust programming course or as a packaged operating system that a user can install and boot. The clearest distinction is between instructional content and documentation tooling. The repository includes chapter sources, an `outline.md`, scripts, a `Makefile`, and Sphinx dependencies. The README does not present the project as an installer for a kernel image, a hosted development environment, or a command-line application. A prospective user should therefore decide whether they want to read and build the tutorial before asking whether the repository can serve as a standalone kernel project. The deployed page at `https://rcore-os.cn/rCore-Tutorial-Book-v3/` offers a direct way to consume the book. Building the same site locally is more useful when readers want control over the source tree, want to inspect the Sphinx configuration, or intend to contribute changes. The local result is documentation under `build/html`, not a compiled operating-system kernel. ## Sphinx Structure Behind the rCore Book The public build mechanism is conventional Sphinx. The `Makefile` sets `SOURCEDIR` to `source` and `BUILDDIR` to `build`, then invokes `sphinx-build -M html` for the `html` target. Warnings are treated as errors by default because `SPHINXOPTS` is set to `-W`. That setting makes the build strict: a documentation warning can stop HTML generation rather than being left in the output. The source tree therefore flows from files under `source`, through Sphinx configuration and extensions, into HTML under `build`. The dependency list includes Sphinx 4.3.2, `sphinx-rtd-theme`, `furo`, `sphinx-tabs`, and `sphinxcontrib-mermaid`. The presence of Mermaid support is reflected in the build target, which copies `scripts/mermaid.js` into `build/html/_static/` after HTML generation. Some repository responsibilities are less visible from the cleaned README. A `puppeteerConfigFile.json` indicates that part of the publishing or content workflow may use Puppeteer, but the README does not explain when that file is invoked. Likewise, `os-lectures`, `scripts`, `all.sh`, and `show.sh` show that the repository contains more than a bare collection of Markdown files. Their exact runtime behavior is not documented there, so they should not be treated as prerequisites without checking their contents. This architecture makes the book suitable for contributors who understand static documentation. It also creates a visible maintenance boundary: readers interested in kernel code must locate and inspect the instructional source material, while readers interested in publishing must deal with Sphinx and its pinned dependencies. ## Installing Sphinx and Building the Book Locally The README provides a complete local documentation workflow. On Linux or macOS, the documented virtual-environment command creates `venv`, and activation places that environment's commands first on the shell path. The repository also supports Windows activation through the matching `venv\Scripts\activate` command. ```bash python3 -m venv venv source venv/bin/activate venv\Scripts\activate ``` The README presents these as alternatives by platform. On Windows, use the second command rather than the Linux or macOS activation command. After activation, install Sphinx and then the pinned project dependencies. Installing the full `requirements.txt` file is the documented approach for reproducing the repository's intended dependency set. ```bash pip install -U sphinx pip install -r requirements.txt ``` A clone must include submodules because the documented command uses `--recursive`. Replace the example account name with your own only after forking the repository. ```bash git clone --recursive https://github.com/YOUR_USERNAME/rCore-Tutorial-Book-v3.git cd rCore-Tutorial-Book-v3 ``` The final build invokes the repository's `html` target. Because the Makefile enables `-W` by default, the command should complete without Sphinx warnings. The README places the generated site at `build/html`. ```bash make html ``` Open `build/html/index.html` in a browser to begin with the locally generated book. On Windows, the repository includes `make.bat`, but the README does not provide a separate Windows build transcript, so the command shown here is confirmed only as the documented `make html` workflow. ## Pinned Dependencies and the 2022 Sphinx Stack The project pins its documentation dependencies rather than accepting current package versions. Examples include `alabaster==0.7.13`, `Jinja2==3.1.2`, `Sphinx==4.3.2`, and `furo==2022.6.21`. The file also includes pinned packages associated with the rendering stack, localization, syntax highlighting, diagrams, and HTTP requests. This improves repeatability in one respect: a build attempted later starts from the versions recorded by the project. It also raises an upgrade cost. A contributor who changes Sphinx, theme extensions, or transitive packages must check the documentation build and its Mermaid output rather than assuming that current releases are drop-in replacements. The README does not document an upgrade procedure for the dependency set. The Makefile also assumes standard Unix command-line tools for the documented path. The `html` target copies a script with `cp`, while `view` invokes `firefox`. Those commands are concrete boundaries rather than abstract platform concerns. The repository contains `make.bat`, but the README does not state which dependencies that file expects. For production deployment, the `deploy` target cleans the build, regenerates it, copies the Mermaid script, runs `python3 scripts/fix-comments.py`, copies the result into `docs`, creates `.nojekyll`, commits every change, and pushes it. That target has direct version-control side effects. Based on the commands shown in the `Makefile`, it is unsuitable as a casual preview command. ## Hosted Pages Versus a Self-Built rCore Book There are two documented ways to access the content. The deployed page is the lower-friction option: it is already hosted at `https://rcore-os.cn/rCore-Tutorial-Book-v3/`. That approach separates readers from the local Sphinx toolchain, but the README does not describe offline availability, search behavior, or the deployed build's exact version. Building from the repository follows a different path. It requires Python, package installation, a successful strict Sphinx build, and manual access to `build/html/index.html`. In return, the reader works from the checked-out `source` tree and the repository's pinned dependencies. This is the more appropriate choice for documentation work and local inspection of the book's configuration. The repository is not a documented alternative to another operating-systems textbook, and the README does not support claims about a competing book's depth, architecture, or target hardware. Its actual alternative approach is hosted-page consumption versus locally generated Sphinx documentation. The choice depends on whether the requirement is simple reading or source-level documentation control. ## Maintenance Signals and GPL-3.0 Reuse The repository is not archived, and its last push was on 2026-07-03. A release named `20260616-0929` was published on 2026-06-16. These are recent repository maintenance signals, although the README does not describe a support policy for the book or a compatibility promise for its kernel examples. The repository is licensed under `GPL-3.0`. That matters when the tutorial text, diagrams, scripts, or code are copied, modified, or redistributed. The license identifier does not answer whether a particular use is permitted in a specific distribution or deployment. Anyone reusing substantial material should inspect the actual `LICENSE` file and assess how the terms apply to their intended use. The clearest adoption cost is documentation maintenance. Contributors may need to deal with strict Sphinx warnings, Mermaid assets, theme compatibility, and the gap between old pins and newer Python environments. The README does not provide automated test guidance for kernel code, rollback instructions for deployments, or a statement about long-term support for individual chapters. ## Conclusion Adopt this repository if your goal is to study the Chinese rCore OS tutorial and maintain its documentation. Do not choose it as a ready-to-run kernel distribution or as a replacement for a documented reference implementation. Check the generated `build/html/index.html`, the chapter code and its toolchain assumptions, and the GPL-3.0 implications for any material you reuse before adopting it. ## FAQ ### How do I build rCore-Tutorial-Book-v3 locally? Create and activate a Python virtual environment, run `pip install -r requirements.txt`, and execute `make html`. The generated site is placed under `build/html`. ### Does rCore-Tutorial-Book-v3 include an installable operating-system kernel? The repository is presented as a Chinese-language book about writing OS kernels in Rust, not as a packaged kernel application. The README documents building the book with Sphinx rather than installing a kernel image. ### Which Sphinx version does rCore-Tutorial-Book-v3 pin? The repository's `requirements.txt` pins `Sphinx==4.3.2` and also pins its theme and extension dependencies. ### Can I run the rCore-Tutorial-Book-v3 `deploy` target as a preview? No. Based on the `Makefile`, it cleans and regenerates the site, runs `python3 scripts/fix-comments.py`, stages all changes with `git add -A`, creates a `Deploy` commit, and pushes the branch. Use `make html` for the documented local build. ## Sources - [License: GPL-3.0](https://github.com/rcore-os/rCore-Tutorial-Book-v3/blob/main/LICENSE) - [Project website](https://rcore-os.cn/rCore-Tutorial-Book-v3/) - [rcore-os/rCore-Tutorial-Book-v3 on GitHub](https://github.com/rcore-os/rCore-Tutorial-Book-v3) - [README](https://github.com/rcore-os/rCore-Tutorial-Book-v3/blob/main/README.md) - [Releases](https://github.com/rcore-os/rCore-Tutorial-Book-v3/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/rcore-os-rcore-tutorial-book-v3