Go · SQLite · Datastar
lith is the runtime under the Go apps of zwei und eins: one SQLite file, one writer that applies every change in order, views rendered once per tick for everyone who watches them, and HTML streamed to each browser over server-sent events.
The name is the design: each letter is one rule the runtime keeps, and each rule has a package behind it.
Every change is a command, and one writer applies them in the order they arrive. It takes all the commands waiting into one transaction, with a savepoint each: a command that fails rolls back alone, and the rest commit together. The more people write at once, the more commands share each commit.
How Linear writes worksA region of a page is a function of the database: view = f(state). The server renders it whole, in one read transaction, and Datastar morphs the new HTML into the page. No state in the browser guesses what the server will say, so there is nothing to reconcile.
How Immediate mode worksA commit names the topics it touched, and every view that listens to one of them turns dirty. Once per tick, 50 ms by default, each dirty view renders once and its frame goes to every stream that watches it: two hundred tabs on one board cost one render.
How Ticks worksFrames reach the browser as Datastar events over server-sent events. Each stream compresses with a window of its own, so a frame that repeats most of the last one costs a few hundred bytes, and a memory budget shrinks the windows as more streams open.
How Hypermedia worksIn process, on an Intel i5-13500 under Linux, in October 2026. With synchronous=NORMALSQLite syncs the log only at checkpoints: a power loss can undo up to about 35 s of commits, a crash of the process none. FULL syncs every batch. unless it says otherwise.
How each number was taken, with the commands to run it again: bench/RESULTS.md. The kanban numbers come from kanban's own load tool.
A new module from lith's template, its guestbook running.
go run github.com/zweiundeins/lith/cmd/lith-new@latest \
~/guestbook example.com/you/guestbook
cd ~/guestbook && go mod tidy
go tool task dev # http://127.0.0.1:8080lith in a module of your own: then wire the database, the writer and the hub in main.
go get github.com/zweiundeins/lith@latestA project on a lith checkout: its go.mod gets a replace directive for the checkout, for work on both.
git clone https://github.com/zweiundeins/lith ~/src/lith
cd ~/src/lith && go run ./cmd/lith-new -lith . ~/guestbook example.com/you/guestbookEach demo runs on this server, on lith, with the code that does it beside it.
Sign the book: the entry reaches every open tab in the next tick, and only your tab hears if it was refused.
Up to 200 producers send commands to one writer for three seconds, and everyone watching sees the batches grow, tick by tick.
Your own stream, live: what the hub sends this tab, what zstd makes of it, and what the memory budget gave its encoder.
Paint on one pixel canvas with everyone here: each stroke is a command, and one render a tick carries the board to every painter.
Drag a card to another lane: the board renders once in the next tick, and every open tab sees it glide there.
Every visitor's pointer, live: each tab sends its position 15 times a second, and one view draws them all once per tick.
One grid of a million boxes for everyone: tick one, and every tab that has it in view sees it flip within a tick.
One board for everyone: the server computes ten generations a second while anyone watches, and every tab gets the same frame.