Go: Under The Hood, a source code book rebuilt around Go 1.26

A book project, not a library, with a stated reason to exist

The first thing to know about this repository is that it contains no code you import. It is a book, published as Markdown under `book/`, rendered into a site, and written by one primary author with corrections from a named list of readers. The description field points straight at the online edition at golang.design/under-the-hood, which is where you are meant to read it.

The README opens by making an observation about Go's history that sets the whole project up: Go has existed for more than a decade, and over that period the language itself has not changed very much, so users have been able to keep writing backward compatible applications. Given that, the author argues, it is natural to be curious about the mechanisms behind the simplicity, and that is the book's subject. It covers technical principles and the history of their evolution in Go's source tree.

The author's stated answer to why anyone would study source code they will never touch is worth quoting as a position rather than a slogan: software engineering happens when code is read by someone other than its author, and reading source deepens understanding of a design's underlying principle as well as of the engineering decisions and implementation techniques involved. The conclusion drawn is that code can be thrown away and rewritten, while principles endure. That framing is why the book spends time on why a mechanism exists rather than only on what it does.

The Go 1.26 rewrite and its six parts

The version story is the most concrete fact about the project. The README states the current content is based on `go1.26`, and the section on the book's version says the whole thing was systematically rewritten and revised against Go 1.26, covering six major parts: panorama and history, language features, concurrency, memory, the compiler and toolchain, and heterogeneous computing and AI.

That six part structure is also visible in the pull request titles attached to the single release on record, which name chapter and section paths directly: `ch11type.interface`, `part2runtime/ch09lang/chan.md`, `ch08GC`, `ch06sched`, `stack.md`, and a fix in ch07alloc. From those filenames you can reconstruct a rough table of contents: type interfaces and their runtime representation, channels and select, the garbage collector, the scheduler, the stack, and allocation.

The rewrite follows a stated through-line for every section: problem, design, evolution, tradeoffs, implementation. Each claim is meant to be checked against the Go source and against first party design documents, which is the standard that separates this from a blog post collection. The README also acknowledges the unavoidable limit, since the source keeps changing, and invites issues and pull requests for corrections.

For the English reader there is one hard fact to check first: the README carries a `lang-简体中文` badge and is written in Simplified Chinese throughout. There is an English README in the repository, but it is a landing page, not a translation of the chapters.

What the repository actually contains

The tree is short enough to take in at a glance, and every entry has a clear job:

book/
website/
tools/
README.md
README.en-us.md
CONTRIBUTING.md
CODE_OF_CONDUCT.md
LICENSE

`book/` holds the Markdown text, `website/` holds the site that renders it, and `tools/` holds whatever builds or serves that site. The repository is HTML by the language detection GitHub applies, which tells you the markup outweighs the prose in the file statistics.

The two README files sit side by side, which is the clearest signal about how the project expects to be used. `README.md` is the Chinese original and `README.en-us.md` is the English one, and both carry the donation badges for WeChat, Alipay and PayPal that a donation funded book normally has.

`CODE_OF_CONDUCT.md` means the project follows a contributor code of conduct, and `CONTRIBUTING.md` is linked from the README as the place with the actual rules. The author asks for issues and pull requests directly in the repository rather than restricting questions to a chat channel, and asks readers to open an issue before writing a large change so the work is not wasted.

Reading order, prerequisites, and what the book assumes you know

The README is unusually precise about who the book is not for, and that is more useful than a generic audience statement. Readers need basic computer science training: at least one programming course and one data structures course, enough to talk about hash tables and red black trees. Knowledge of discrete mathematics and probability helps with some chapters, specifically ones involving predicates and random variables.

What the book does not require is Go experience. That is stated directly, with the promise that the opening introduces the Go language specification quickly, and the observation that readers who already have Go coding experience will find the material easier. So there is no prerequisite Go course and no assumption you have shipped in the language.

The platform scope is also named: the book discusses implementation differences between platforms in places, but focuses on Linux/amd64. That is a useful warning for anyone on darwin or arm64 who is trying to match stack traces against the text.

The stated ambition is coverage of the whole language: the runtime components user code touches directly, the toolchain behind key language features, and the important parts of the standard library. The online edition at golang.design is the entry point, and the README says both the homepage and the repository carry update status and additional reference material.

CC-BY-NC-ND 4.0 and what it means for anything you build on it

The licensing is the detail most likely to surprise an English reader, because GitHub's license detection on the repository reports MIT while the README's own licence section says something else entirely. The README states the content is copyright 2018 to 2026 the golang.design Initiative Authors and licensed under CC-BY-NC-ND 4.0, and there is a matching badge at the top of the file. The `LICENSE` file in the tree is the one to read.

Those four letters each remove an option. BY means attribution is required, which is easy. NC means non commercial, so you cannot sell a course built on the text. ND means no derivatives, and that is the binding one for anyone who wants to translate the chapters, fork them, or restructure them into their own material. You may read the book, quote short passages with credit, report errors, and contribute corrections upstream. You may not publish an English edition under your own name.

If the subject matter rather than the text is what you need, the situation is different. The Go source code and its design documents are separately available under their own terms, and the book is explicitly a reading of those. Building your own explanation from the primary sources is not derivative of the book in the sense the licence prohibits, which is the route to take if a translated edition is the actual goal.

One release exists on the repository, v1.26-alpha.1 published on 2026-06-09, and its contents are almost entirely typo and formatting corrections across chapters. The last push to main was on 2026-09-01, so the pattern is a periodic rewrite for a new Go release followed by a long tail of small reader corrections, which is the maintenance model you should expect from a book rather than a library.

Editorial conclusion

This book is a good fit for an engineer who already writes Go and has reached the point where the language spec no longer explains a problem, and a poor fit for someone looking for a tutorial or for English prose on the runtime. What it gives is a documented argument about why the runtime looks the way it does, tied to named source files and design documents, and the Go 1.26 rewrite means the chapters track a current release rather than the 1.18 era most comparable material still describes. Two practical notes decide whether it is usable for you. The text is Simplified Chinese, so the English README in the repository is a landing page rather than a translation of the chapters. And the CC-BY-NC-ND 4.0 licence forbids derivatives, so you can read it, quote it with attribution, and report errors through issues, but you cannot fork the chapters or publish a translated edition. Start with the ch07alloc memory chapter if your problem is allocation, and read the online version at golang.design before cloning anything.

Frequently asked questions

Official sources

1. golang-design/under-the-hood on GitHub
2. License: MIT
3. Project website
4. README
5. Releases