A 100 KB Git-Like VCS That Beats Git at Its Own Game

I have been building agents and small tools for years, and every time I reach for git inside an automated workflow I hit the same wall: git is a miracle of engineering, but it is also a large, interactive, human-oriented tool with a protocol and pack format that are overkill for a script that just wants to snapshot some files and push a hash over HTTP. So I built lume.

lume is a tiny, content-addressed version-control system written in machin/MFL. It is git-like, not git-based. It borrows git's vocabulary — blob, tree, commit, refs, HEAD — and its content-addressed object model, but the implementation, storage format, and network protocol are written from scratch.

Why not just use git?

Git is irreplaceable for human teams. But for agents and micro-services it carries a lot of baggage: a multi-megabyte binary, pack-file archaeology, a wire protocol that needs negotiation, and a staging index that is a binary black box. lume replaces all of that with a single 100 KB native binary, plain JSON objects, and a tiny HTTP object exchange.

The benchmark that matters

I measured the one workflow every developer repeats dozens of times a day: stage everything and commit. On a Linux workstation, using 110 small source files, the results are:

• lume add . && commit: ~15 ms
• git add . && commit: ~17 ms
• lume binary size: 100 KB
• git binary size: 3.7 MB

lume is faster on the hot path and about 36 times smaller. The repo metadata size is within 2% of git's after the first commit.

How it stays fast

The biggest win came from replacing the SQLite staging index with a line-delimited .lume/index.lst file. Instead of opening a database, preparing parameterized statements, and waiting for fsync, lume add builds a small tab-separated string and writes it once. commit then reads that string, builds the tree, and writes the commit object in a few milliseconds.

Blobs are written through a hand-rolled JSON fast path so the common case — store a file, hash it, put the hash in the index — does not pay for generic reflection. Object subdirectories are created lazily with a single mkdir call per prefix, so init no longer pre-creates 256 empty directories.

HTTP push, pull, clone

lume ships with a built-in serve command. It exposes a handful of JSON-over-HTTP endpoints: /info, /refs, /objects/<hash>. push walks the commit graph and uploads missing objects. clone and pull fetch the remote ref and rebuild the working tree and index. No SSH keys, no pack negotiation, no stateful transport.

What's next

lume is still young. Merge, rebase, and diff are not implemented yet, and the file-mode detection is Linux-oriented. But the core loop — init, add, commit, push, pull, clone — is now fast enough to sit behind an agent without the agent ever knowing it is talking to a VCS.

If you want to follow along, the source and benchmarks are on GitHub. Everything else I build lives under intrane.fr.