The Pocket Republic
Found a tiny country, fork it, hand it to a friend, merge your histories back.
The ingredients 10 gifts
The idea
A serverless constitutional sandbox — a small institution with a founding rulebook and an append-only history of decisions — built entirely from these parts. No account, no backend. The current state isn't stored, it's derived by folding the whole event history: state = fold(constitution, event₁ … eventₙ). Replay the same history, get the same country.
The parts + how they wire
loop21-component-factory (a source emitting validated specs for logic primitives — counter, toggle, clamp, accumulator) builds the rule primitives (a term-limit is a counter + a clamp + an eligibility matcher). mint issues permanent, never-reused citizen/office IDs and proves non-reuse before returning each one. callsigns gives every proposal a speakable word-word-hash name. Actions travel only along declared routes via tracebus. A civic decision that should stay open-until-committed runs through dwell as a ceremony. Fork it, a friend's copy diverges, vclock sorts out which events were concurrent at merge, trellis localizes a conflict to the exact cell. timeline validates the whole history is sound before render; l21x-snapshot + sha256 are the portable, content-addressed .republic file you hand someone.
The one piece you build
The runtime that executes those rule-specs and the merge algebra — which event types auto-combine, which conflict mechanically, and which must never auto-merge. That's the real 80%, and it's genuinely hard.
The technical breakdown
dwell gives replayable deliberation for free, and the mechanism is unusual — reversal-indexed routing: a cart circles a loop of n ticks, holding is free (an extra lap changes nothing), it leaves only when you reverse, and which of k exits it takes is a pure function of the phase at the instant of reversal (phase = (reverse − entry) mod n; exit = (phase * k) // n). 'Deliberate as long as you want, the moment you stop is the decision' is literal, and replay reproduces the exact outcome — for an auditable governance ceremony, this is the primitive. vclock is the concurrency oracle with exact semantics: compare(x, y) returns before / after / concurrent / equal by componentwise comparison; merge is componentwise maximum — your entire 'did these two branches know about each other' test, done. The merge algebra you write sits on top of vclock's verdict: for each event type you declare auto-combine, mechanical-conflict, or always-return-to-human (constitutional amendments — never auto-merged regardless of what vclock says). trellis does the conflict localization — a double word square run to arc-consistency; a detected break localizes to the single cell where the failing row crosses the failing column, naming both failing words (Treasury × Works), not a vague merge error.
The honest edge
vclock can tell you two edits were concurrent; it cannot tell you they're semantically compatible. Two branches that each legally spent the last 40 coins merge into a negative balance — both events are causally independent, vclock correctly calls them concurrent, and that's still a bug your merge algebra has to catch. The tools surface the disagreement; a human still rules. For anything modeling governance, that's the correct design, not a shortcoming.
These are ingredients, not instructions you have to follow. If you cook something from them — or something stranger — we want to see it.