Complex systems that just work.

A prediction league for the 2026 World Cup. Friends and family called the score of all 104 matches; a scoring engine settled the arguments.

Built as a single Cloudflare Worker: the React SPA ships as static assets, a Hono API handles auth, predictions and rankings, D1 holds the state and KV absorbs the traffic. During the tournament, scheduled jobs synced live results and news — retired now that the cup is over, the site stays up as a freeze-frame of the final table.

A competitive murder-mystery logic game, adapted from the puzzle book genre: read the clues, place every suspect on the floor plan, accuse the killer — faster than everyone else.

The heart of it is a constraint solver that proves every published case has exactly one solution before players ever see it. An admin builder composes rooms, furniture and structured clues that render as natural Portuguese sentences; players race a server-side clock with a single accusation each, solo or in teams, over an F1-style season leaderboard. Same calm architecture as the bolão: one Cloudflare Worker, D1, KV.

A Totobola-style prediction game for the Portuguese league. Call 1X2 on every matchday; correct calls earn points and half a star — stars buy doubles and triples, just like the real coupon.

Matchdays in the Liga sprawl unpredictably across Friday-to-Monday, so there is no single deadline: every match locks server-side at its own kickoff. Hourly jobs rebuild the calendar from football-data.org — new rounds appear on their own, rescheduled games move themselves — and a 15-minute results pass only spends API calls when matches are actually hot. Same calm architecture: one Cloudflare Worker, D1, and an idempotent scoring engine an admin can always override by hand.

A four-player arena game in the spirit of the bomb-laying classics: blast crates, grab power-ups, trap your friends. Room codes, online multiplayer, bots that hold their own.

The whole simulation is one deterministic Rust crate — integer-only math, seeded RNG — compiled to WebAssembly and run twice. In the browser it powers offline practice; on Cloudflare it lives inside a Durable Object, one per room, ticking 20 times a second as the sole authority on every match: the sim itself validates each move, so a modified client can't cheat physics. State streams to players as compact binary snapshots over WebSockets; the canvas just interpolates and draws the neon.

Hangman for a crowd: rooms of up to ten, one secret word, and a personal gallows per guesser. Wrong letters are yours alone — the word belongs to everyone.

After Kabum's Rust-and-wasm adventure, this one is deliberately boring tech doing a social job. The entire rulebook — turns, per-player gallows, the word-setter role the room's owner can assign and the setter can pass on, hint reveals, full-word risks, sit-outs, the persistent room scoreboard — is a single pure TypeScript state machine, shared verbatim by client and server and pinned down by thirty unit tests. A Durable Object per room wraps it with WebSockets and a 45-second turn clock, broadcasting personalized views: only the word's creator ever sees the secret, and accented letters match their plain keys, so CORAÇÃO yields to a C.

Striker (Cult Games, 1989) gave the ZX Spectrum a whole football career — Division Four at 18, retirement at 34 — and resolved every chance with one sweeping bar and the S key. This rebuild keeps the 1989 career and gives it a stage.

It started faithful — green paper, bitmap ZX font, wireframe goalmouth — and one playtest later the verdict came back: keep the career, lose the skin. The shipped game is a floodlit rebuild in this site's own machine-room language: dark DOM menus carrying the original's key letters, and a canvas match stage with the camera behind the striker — perspective pitch, a keeper who sets and dives, a net that ripples when you score. Every chance — one-on-one, header, volley, penalty, spilled rebound — is a two-phase skill shot: a reticle you steer along the goal frame, then a power bar with a sweet zone, judged by a keeper that reads centrality and power quality and dives the right way only if he reads it. Around the goalmouth sits the full career: thirty-week seasons with cup rounds and internationals threaded between league weeks, a weekly three-chance shooting drill that sharpens whatever regime you picked, summer transfers to Italy, France, West Germany or Spain, promotion and relegation, honours. Still no build step and no server — static files on a Worker, fonts self-hosted, three save slots plus autosave in localStorage, and saves from the first build load unchanged. Before each ship, a headless harness played a full seventeen-season career to retirement.

King is the card game every family plays slightly differently: ten hands, six that punish you for winning tricks and four that pay you for it, and a scoresheet nobody ever explains to the newcomer at the table. This build deals the rules alongside the cards.

A table needs four, and the rules take a night to learn — so the room fills itself. Any empty seat takes a bot at one of three levels: naive, heuristic, or one that counts what has already fallen. The only hard rule is that at least one human sits down. The teaching layer isn't a tutorial you skip on the way in: every hand opens with its own brief — what it costs, what to avoid, one piece of advice — the score table is live and opens row by row to show the arithmetic (units × value, and the exact cards that scored), and between hands a recap replays what the trick pile actually cost you. Six negative hands drain to −160 on the King of Hearts alone; four positive hands pay +25 a trick with the dealer naming trumps; the whole match sums to exactly zero, which is the fact that finally makes the scoresheet legible. Underneath is the same spine as the other room games — a pure state machine with zero I/O, one Durable Object per room, the room evaporating when the last player leaves. The constraint worth the trouble: the engine has no words. It emits codes, never sentences, so all six languages live in the client and four players can read the same table in four different languages. The 45-second clock runs only while a connected human holds the turn — a disconnect pauses it, a rejoin restarts it — bots think for two thirds of a second so a human eye can follow the table, and if someone walks out mid-match a medium bot takes their seat so the other three still get their ten hands.

Interactive gamebooks in the 1980s solo-adventure tradition: read a passage, choose, roll two dice against SKILL or LUCK, fight in rounds, carry a poison until you find the cure. Lume is the first of these machines built to be paid for — and the money is why the architecture looks the way it does.

A story is pure data: a manifest, an item and status dictionary, and a graph of passages with choices, requirements, effects and encounters. It lives in the worker and never reaches the browser whole — a passage is revealed only when a turn is spent on it, and the response carries just that page, the visible choices, and the dice log. The engine is a pure state machine over that data: no I/O, replayable from a seed, exercised by unit tests and by a Monte Carlo reader that walks each story hundreds of times before deploy to prove every ending is reachable and that death is neither certain nor impossible. The dice are xorshift over a seed that advances with every roll and is stored with the run, so nobody — not the client, not the author — can nudge them. The economy is one place where correctness is money: three free turns refill at midnight and bank up to nine, paid turns never expire, and a subscription simply makes every turn cost zero. Spending a turn and advancing the story are one D1 batch with cross-conditional updates — the run advances only if the wallet can pay, the wallet is charged only if the run advanced, the log is appended only if both happened — so a double-click or a second tab can never burn a turn without a page, or reveal a page without a turn. Stripe is spoken without an SDK: hosted Checkout with inline prices, a WebCrypto check of the webhook signature, and an event table that makes every delivery idempotent. The authoring studio the original blueprint imagined was deferred on purpose: git is the studio, the lint is the reviewer, and the simulator is the playtester.