Lularible/storage-book: A Storage Technology Book With a Working Filesystem Inside
An open-source book on storage technology and file systems. From knot records to Flash physics, from FAT to LittleFS — complete with KnotFS, a teaching-grade log-structured embedded file system (~1770 lines C).
At a glance
- What is it?
- An open source book on storage and filesystems, from knot records to Flash physics, plus KnotFS, a teaching-grade log-structured embedded filesystem in about 1770 lines of C. Here is what it covers, how to build the code, and where it stops being the right tool.
- Who is it for?
- Adopt Lularible/storage-book if you want a structured path from Flash physics to a runnable log-structured filesystem, and if you are willing to read Chinese. Do not adopt it if you need a production-grade filesystem, an English translation, or a stable tagged release to pin.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository last received commits 20 days ago.
- What is it written in?
- Mainly C, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- Lularible/storage-book589 ★ · +20
| Repository | 2026-09-21 | 2026-11-15 |
|---|---|---|
| Lularible/storage-book | 569 | 589 |
20 Stars in the last 55 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
What Lularible/storage-book Is Trying to Fix
Most storage material splits into two unsatisfying halves. Vendor datasheets explain Flash physics without ever showing how a filesystem copes with it. Filesystem papers assume you already know why erase blocks behave the way they do. Lularible/storage-book is an attempt to close that gap in one place: a 39-section book that starts with knot records as a way of talking about durable encoding, moves through floating-gate transistors and NOR/NAND cell types, then through FAT, log structuring, wear leveling and power-loss safety, and ends by building a filesystem.
The audience is fairly narrow and the repository is honest about it. The book is written in Chinese, and the fifth chapter is aimed at embedded engineers who want to read source rather than skim theory. The sister projects listed in the README (a PTP book, an HSM book, a UDS book, an ISO 26262 book and others) point at the same reader: an automotive or embedded engineer who wants mechanism-level understanding rather than an API tour. If you are choosing a filesystem for a shipping product and only need a feature matrix, this is not the resource you are looking for.
How the Book Is Structured and Where KnotFS Sits
The repository has two top-level content directories: chapters/ holds the prose, knotfs/ holds the code. The README breaks the book into five chapters of 5, 5, 8, 6 and 15 sections. The first two are conceptual (storage's inherent problems, then Flash physics). Chapter three is the theory chapter, covering thought experiments, FAT, log structuring, wear leveling and power-loss safety. Chapter four is a source walkthrough of LittleFS, naming Metadata Pair, CTZ Skip-List and the Block Allocator as the mechanisms it examines.
Chapter five is the part that distinguishes this from a reading-only book. It builds KnotFS, described in the README as a teaching-grade asynchronous log-structured filesystem in pure C at roughly 1770 lines, and it includes discussion of production integration. That last phrase matters more than it looks: a log-structured design that is asynchronous has to say something about when data becomes durable, and the README's framing suggests the book treats that as a design conversation rather than hiding it. The book itself is published as a static site through an mdBook reading site maintained by a contributor credited in the acknowledgements.
Building KnotFS and Running Its Tests
The README gives a short quick start. It assumes you are already in the repository root and that a C toolchain and make are available. There are no documented package dependencies, no configure step and no environment variables.
cd knotfs
make && make testThe first command moves into the directory that holds the filesystem source. The second builds it and then runs the test target. According to the README, this is the complete documented path from a clone to a passing test run. If make test fails, the README does not list expected output, a known-good compiler version, or a troubleshooting section, so you are reading the source to find out what went wrong.
For reading rather than building, the README points at a hosted online version of the book and gives this address.
# online edition referenced by the README
# https://web-l.github.io/lularible-books/storage-book/index.htmlThe repository also contains a rendered screenshot of KnotFS in the README, which is the only visual of the running system the README provides.
The Limitations You Should Know Before Committing
Three constraints stand out. The first is language: the book is in Chinese, and the README is the only English-language surface. An English-speaking engineer can build and read KnotFS because it is C, but cannot follow the fifteen sections of reasoning that explain why it is written that way.
The second is scope. KnotFS is explicitly a teaching artifact. The README calls it teaching-grade, and the size confirms it: roughly 1770 lines covers a log-structured design and little else. There is no mention of a POSIX interface, a mount tool, concurrency guarantees, or a documented on-disk format specification. The book discusses production integration as a topic, not as a delivered feature. If you need a filesystem that survives a hostile power-loss test regime on real hardware, the README gives you no basis to claim KnotFS does.
The third is release discipline. The repository has no published GitHub releases, so there is no tagged version to pin. The last push was on 2026-09-03, which is recent, but a moving master with no tags means anyone vendoring the code should record the exact commit they built. The repository is not archived.
KnotFS Versus LittleFS: Why Both Are in the Same Book
The obvious alternative is LittleFS, and this repository treats it as one. Chapter four is a LittleFS source analysis covering Metadata Pair, CTZ Skip-List and the Block Allocator, so the book's position is that you should understand the mature implementation before writing your own. That is a real difference in approach from a project that presents its own code as the answer.
The practical difference for a reader is depth against dependability. LittleFS is a filesystem you can put in a product; its mechanisms are documented in the book's own chapter and in its upstream project. KnotFS is the same design space reduced to something a person can read end to end in an afternoon, with the asynchronous log-structured path made visible. Choosing between them is not a performance question you can settle from this repository, because no benchmark numbers appear in the README. It is a question of whether you want a component or an explanation. If you want the explanation and already know LittleFS by name, the pairing in this book is the reason to read it.
Licensing and the Cost of Keeping Up
The README states two licences: the book content is CC BY-NC-ND 4.0 and the KnotFS source is MIT. The repository's own licence metadata is reported as NOASSERTION, which does not match either of those strings, so the file in LICENSE is worth opening yourself before you rely on the README's summary. The practical reading is that the code is permissively licensed while the prose is not: NoDerivatives and NonCommercial restrictions on the book mean a translation or an adapted chapter is not something the README grants. This is a description of what the files say, not legal advice.
Upgrade cost is low in the sense that there is nothing to upgrade to. With no published GitHub releases, there is no version to track and no changelog to read. The cost is instead in reproducibility: a reader who wants to cite a specific state of KnotFS has to pin a commit hash. The last push was on 2026-09-03, so the repository is current, but current is not the same as versioned.
Editorial conclusion
Adopt Lularible/storage-book if you want a structured path from Flash physics to a runnable log-structured filesystem, and if you are willing to read Chinese. Do not adopt it if you need a production-grade filesystem, an English translation, or a stable tagged release to pin. Verify three things first: that the online reading site renders, that make and make test pass on your toolchain, and which licence applies to the part you plan to reuse, since the book and the KnotFS source are licensed differently.
Frequently asked questions
How much storage is one book?
The README does not give a size or storage figure for the book. It describes the book as 39 sections across five chapters, and describes the KnotFS source as roughly 1770 lines of C.
What are the different types of book storage?
The book's own structure is the closest answer the README supports: it moves from knot records and Flash physics through NOR and NAND, SLC, MLC and TLC, then through FAT, log structuring and wear leveling, and finally builds KnotFS. That is a progression through storage mechanisms rather than a list of storage products.
What is Lularible/storage-book about?
It is an open source book on storage technology and filesystems, running from knot records to Flash physics and from FAT to LittleFS, with a fifth chapter that builds KnotFS, a teaching-grade log-structured embedded filesystem in pure C at roughly 1770 lines.
How do I install and run Lularible/storage-book?
The README's quick start is to change into the knotfs directory and run make && make test. There is no documented installer, package dependency list or environment variable.
Is Lularible/storage-book actively maintained?
The repository is not archived and the last push was on 2026-09-03. The repository has no published GitHub releases, so there is no tagged version to pin.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/lularible-storage-book)Star history chart for your README
[](https://hysenlabs.com/projects/lularible-storage-book)Was this useful?