geektutu/7days-golang: Building Gee, GeeCache, GeeORM and GeeRPC from Scratch

What 7days-golang actually is, and who the seven-day format is for

The repository is a collection of from-scratch Go implementations, each split into seven daily steps. Four tracks are documented in the README: Gee, described as a gin-like web framework; GeeCache, described as a groupcache-like distributed cache; GeeORM, an object relational mapping library whose interface design references xorm with some implementation details from gorm-v1; and GeeRPC, built on the standard library net/rpc and described as roughly 1k lines with protocol exchange, service registration and discovery, and load balancing added. There is also a demo-wasm directory with four WebAssembly examples and a gee-bolt entry in the repository root.

The audience is narrow and the format is deliberate. Each day pairs an article on geektutu.com with a code directory, so the unit of work is one concept: the http.Handler interface on day one of Gee, LRU eviction on day one of GeeCache, database/sql on day one of GeeORM. If you want a library to import, this is the wrong shape. If you want to understand why a router uses a trie, or how singleflight stops cache breakdown, the day-by-day split is the point.

How the Gee, GeeCache, GeeORM and GeeRPC tracks are structured

Each track is a directory tree with one subdirectory per day, and the code accumulates rather than branching. In gee-web, day1-http-base is followed by day2-context, day3-router, day4-group, day5-middleware, day6-template and day7-panic-recover. In gee-cache the sequence runs from day1-lru through day2-single-node, day3-http-server, day4-consistent-hash, day5-multi-nodes, day6-single-flight and day7-proto-buf. gee-orm moves from day1-database-sql to day7-migrate. gee-rpc ends at day7-registry.

That layout means you can read day N and diff it against day N-1 to see exactly what changed, which is the real teaching mechanism. The README does not describe a shared module path or a single importable package across the days, so treat each directory as a self-contained snapshot. GeeRPC is the one track with a stated size: about 1k lines. The others have no line count in the README, and there is no benchmark data, no throughput figure and no release history in the repository, so any performance comparison between Gee and gin would be invented.

Installing the repo and running your first day

There is no install command for the project as a whole, because it is not published as a module you pull in. You clone the repository and run a day directory. The README links each day to its own code path, for example gee-web/day3-router for the trie router and gee-cache/day1-lru for the LRU cache.

Start by cloning and entering the web framework track:

git clone https://github.com/geektutu/7days-golang.git
cd 7days-golang/gee-web/day3-router

The README does not list a required Go version or how to run each day, so read the files inside the directory you pick and the matching article before running anything.

Where the tutorial approach stops being useful

The clearest limitation is that none of these are drop-in replacements for the libraries they imitate. Gee is gin-like, GeeCache is groupcache-like, GeeORM is gorm-like and xorm-like, and GeeRPC is built on net/rpc. The README frames them as imitations, and the GeeRPC description gives the scale: about 1k lines. A framework that fits in a tutorial cannot carry the edge cases, the option surface or the compatibility guarantees of the project it models.

The second limitation is maintenance shape. The last push was on 2026-09-05, and the repository is not archived, but the repository has no published GitHub releases, so there is no versioned artifact to pin. If you copy a day directory into a real service, you own it from that moment. The README does not document rollback, deprecation or upgrade paths between days, because days are not versions. Use this when the goal is understanding; reach for gin, groupcache, gorm or xorm when the goal is shipping.

Gee versus gin, GeeCache versus groupcache: the difference in approach

The honest alternative is the library each track imitates, and the difference is not just completeness. gin is a general-purpose web framework with a mature middleware ecosystem; Gee builds a context, a trie router, groups, middleware, HTML templates and panic recovery across seven days so you can see how those pieces fit together. You would pick gin to build a service and Gee to learn what gin is doing underneath.

The same split holds for GeeCache against groupcache. GeeCache walks through LRU eviction, a single-machine concurrent cache, an HTTP server, consistent hashing, multi-node communication, singleflight against cache breakdown, and Protobuf as the exchange type. groupcache is the production-shaped version of that idea. GeeORM sits between gorm and xorm by design: the README states that xorm's design is easier to understand than gorm-v1, so the interface follows xorm while some details follow gorm. If your reason for reading is to choose an ORM for a real schema, read gorm and xorm documentation instead; if your reason is to understand chain operations, hooks, transactions and migration, GeeORM shows the machinery.

Licence and the cost of tracking the repository

The repository is MIT licensed, which permits reuse with attribution and without a copyleft obligation, but this is a description of the licence identifier and not legal advice. If you copy a day directory into a product, keep the licence text and the copyright notice with it.

Upgrade cost is the more practical question, and the answer follows from the layout. There is nothing to upgrade: the repository has no published GitHub releases, and the units are day directories, not versions. Pulling the latest master gives you newer tutorial code, not a bug-fix line you can track. The last push was on 2026-09-05, so the repository has moved recently, but movement in a tutorial repo means the explanation changed, not that an API was stabilised. Budget for reading the diff, not for a dependency bump.

Editorial conclusion

Adopt it if you learn Go by writing the thing yourself and want a guided path from http.Handler to consistent hashing, transactions and a registry. Do not adopt it if you need a maintained library to ship: Gee, GeeCache, GeeORM and GeeRPC are teaching artifacts, and the README presents them as imitations of gin, groupcache, gorm and xorm. Before you start, open one day directory such as gee-web/day3-router and check that the code matches the article you are reading, because each day is a snapshot rather than a continuously updated package.

Frequently asked questions

Official sources

1. geektutu/7days-golang on GitHub
2. Issues
3. License: MIT
4. Project website
5. README