Rust语言圣经 (sunface/rust-course): a Chinese Rust book you read online, not clone

What Rust语言圣经 is, and the reader it is written for

Rust语言圣经 is a book, not a library. The README describes it as a Rust tutorial built for domestic (Chinese) users, aimed at beginners getting started and at experienced developers who want to raise their productivity. The repository is the source of that book: a src/ directory of chapters, a book.toml configuration file, a theme/ directory, and a deploy.sh script, which is the layout mdBook expects. There is no Cargo.toml at the top level and no published crate, so nobody adds this to a project the way they would add a dependency.

The scope claim in the README is specific: more than 170 chapters, more than 1.1 million Chinese characters, and over 800 hours of writing, all hand-written according to the author. That scale is the actual product. A reader who wants a short weekend primer will find this oversized; a reader who wants one place to work through ownership, lifetimes, async, and the surrounding ecosystem has a single continuous text instead of a dozen disconnected blog posts.

The README also points to two companion sites. course.rs is the online reading version, and practice.course.rs is an online exercise site. A third link, beatai.org, is described as a daily AI reading feed and is not part of the Rust material itself. If you are evaluating this for a team, the reading site is the artifact you are evaluating; the GitHub repository is where the text lives.

How the book is assembled: mdBook, src/, and a deploy script

The mechanism is deliberately boring, which is the right choice for a text of this size. book.toml is the mdBook manifest: it names the book, sets the source directory, and configures output. The src/ tree holds the chapters as Markdown, and mdBook renders them into static HTML with the theme/ directory supplying the site's styling. Because the source is plain Markdown, a chapter is editable by anyone who can write a pull request, and the diff is readable in review.

The repository also carries genpdf.sh alongside deploy.sh. That pairing suggests the project produces a PDF build in addition to the web build, which matters if you want to read offline or hand a printable copy to a study group. The README does not document the PDF pipeline's requirements, so treat that script as something to inspect before you depend on it.

The contribution path is the standard one for a book repository: the README thanks contributors by name and links to the contributor graph, and the .github/ directory holds the issue and pull request templates. Text changes are reviewed like code changes. There are no releases in the repository, which fits: a book's version is its commit history, not a tagged artifact.

Reading it without cloning: first steps on course.rs and practice.course.rs

The README gives no installation instructions because there is nothing to install for the normal reader. It lists two URLs, and those are the entry points. The first is the online reading address:

https://course.rs

You should land on the book's table of contents, with chapters grouped by topic. Work forward from the beginning if you are new to Rust; if you already write Rust, jump to the chapters on the areas you avoid, which for most people means ownership, lifetimes, and async.

The exercise site is separate and is where the material stops being passive:

https://practice.course.rs

The README describes it as an online practice site. Expect to write code in the browser rather than in a local project, which lowers the setup cost to zero but also means you are not learning your own toolchain, your editor, or cargo's error output in the same session.

Building the site yourself is possible because the repository is an mdBook project, but the README does not give the build command, the required mdBook version, or the preconditions for deploy.sh and genpdf.sh. Read those scripts and book.toml before wiring the book into any automated pipeline.

Where this book is the wrong tool

The language is the first boundary. The README is written in Chinese and the book is described as built for Chinese-speaking users. If you do not read Chinese, none of the 1.1 million characters are available to you, and no amount of repository tooling fixes that. The official Rust Book and the Rust nomicon are named in the README as source material and are available in English; for an English reader they are the direct route.

The second boundary is the licence. The README states the project chose No License, which it explains means readers may fork and read freely but may not privately modify and then repackage and distribute. That is a real constraint on corporate use. A company that wants to take chapters, edit them, and ship them inside internal training material is in the territory the README says requires contacting the authors. The README also notes that the borrowed source books are mostly Apache plus MIT dual-licensed and that this project chose to follow the MIT terms among them. Those two statements sit next to each other without a reconciliation, so if reuse matters to you, read the licence section and the linked No License page yourself rather than trusting a summary.

The third boundary is format. This is a linear book. If you want a reference you can query by API name, or a set of runnable examples keyed to a specific crate version, a book is the wrong shape. It is also not a substitute for the compiler: reading about the borrow checker and satisfying it are different activities, which is presumably why the exercise site exists as a separate destination.

How it differs from the official Rust Book and from video courses

The comparison the README invites is with the official Rust Book, which it lists first among the works it drew on. The difference in approach is coverage and language, not correctness. The official book is the canonical English text maintained by the Rust project; Rust语言圣经 is a Chinese text that the README says runs past 170 chapters, which is substantially longer than the official book's chapter list. Extra length in a tutorial usually means more worked examples and more time on ecosystem topics, and it also means more surface area that can drift from the language as the language changes.

Against video courses, the difference is the medium and the cost. The related searches around Rust courses include paid platforms and certificate-bearing offerings. This project is free to read, has no certificate, and no enrollment. What you get instead is text you can search, quote, and link to, plus a public repository where a wrong sentence can be reported and fixed. What you give up is pacing, a schedule, and any external accountability.

Against a general-purpose Q&A site or an AI assistant, the difference is that this is a single authored sequence with a stated editorial standard. The README claims every chapter is hand-written with no compromise on quality. That claim is the author's, not something a reader can verify from the repository metadata; the way to test it is to read three chapters in an area you already know well and judge the accuracy yourself.

Maintenance, licensing, and what upgrading costs you

The repository is not archived, and the last push was on 2026-08-24. That is recent, and it is the only maintenance signal available here: there are no retrieved releases, so there is no changelog to read and no version number to pin. For a book, that is normal but not frictionless. Your upgrade is pulling the latest main branch or re-reading the live site, and the diff you get is whatever changed in src/ since your last read.

There is no dependency graph to audit, no transitive crates, and no build artifact that ships to production, so the operational risk of adoption is close to zero. The risk that does exist is content drift: Rust evolves, and a long Chinese text with 170-plus chapters has many places where an edition change or a library change can leave a passage stale. The repository's issue tracker is the mechanism for that, and the README's contributor list shows the project takes outside fixes.

The licence position deserves a plain statement rather than a legal opinion. The README says the project chose No License and that readers may fork and read but not privately modify and redistribute. If your use is reading, linking, or forking for personal study, that is within what the README describes. If your use is repackaging, translating into another language for publication, or embedding chapters in a product, the README says to contact the authors. Separately, the README states that the borrowed books are mostly Apache plus MIT dual-licensed and that this project followed the MIT terms among them. Consult your own counsel before acting on either statement.

Editorial conclusion

Adopt Rust语言圣经 if you read Chinese and want a single long-form path through Rust, or if you maintain Chinese-language training material and want a source you can point people at. Do not adopt it as a dependency, a crate, or a template you plan to repackage: the README states the project uses No License, which permits forking and reading but not private modification followed by redistribution. Before relying on it, check the two live sites the README lists, course.rs for reading and practice.course.rs for exercises, and read the licence paragraph yourself if you intend to reuse any text. The repository was last pushed on 2026-08-24, so the content is current as of that date.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. sunface/rust-course on GitHub