Happy STL

Category: Projects

  • The Island of Crete: Play the Demo

    The Island of Crete: Play the Demo

    Play the demo right here, or open it full screen for the best experience on a phone.

    Play The Island of Crete full screen →

    What it is

    The Island of Crete is a tile puzzle game set in the Labyrinth. You are Theseus. Gather every relic, open the Daedalus Gate and reach the exit, while the Minotaur hunts you. He takes two steps for every one of yours, always trying to close the gap across before he tries up or down. That one simple rule is the whole game: you win by reading where he will go and leading him into walls, pits and traps.

    The campaign has ten chapters and a hundred levels. Each chapter brings in one new piece of Daedalus’s workshop, teaches it in three short levels, then mixes it with everything before it in seven harder ones. The pieces include gravel the beast can’t cross, walls that rise behind you, false and invisible walls, snares, teleports, rolling bronze balls, Harpies, Talos’s fire, a thief, bombs and a clone machine. There are three tools too: Medusa’s mirror, a wooden cow to lure him, and honey cakes for extra hearts. Story pages hidden in the levels decide which of three endings you get.

    Beyond the campaign there is Endless: new levels made on the fly from a seed, so you can share a seed and a friend plays exactly the same run. There is also a level editor, where you can build your own level, check that it can be won, and share it as a link.

    Two looks

    You choose how the Labyrinth looks. Modern is a painted 3D scene with a free camera you turn with a compass. Classic is a flat, hand-rendered board in the spirit of the old tile games. The puzzle is the same in both; only the view changes, and you can switch at any time without losing your place.

    How to play

    • Move: arrow keys or WASD, or the on-screen pad on a phone. A quick tap is one step; hold it to keep walking.
    • Wait: the period key, or Wait. Sometimes standing still is the move.
    • Undo and Restart: U and R. Walking back the way you came also takes the moves back.
    • Stuck? Ariadne’s thread (H) shows the next step of a perfect solution. Using it marks the try as assisted.
    • Best: every level knows its fewest possible moves. Beat a level in exactly that many for a perfect clear.

    Next in this series: how the game was built, and the decisions that shaped it along the way.

  • How The Island of Crete Was Built

    How The Island of Crete Was Built

    I built The Island of Crete by directing a team of AI coding agents (Muse, Cursor and Anthropic’s Claude Code). I set the vision, made the calls and played every build; the agents wrote the code, the tests and the documentation, each in its own copy of the project, and every change went through automated tests and code review before it could go live. From the first draft on October 8 to November 5, that took 22 days of work spread over four weeks; on the other 7 days nobody worked on it. This post is the story of how it was built, in pictures: how the game grew, how it is put together, and how its levels are made, proved and shared.

    The Island of Crete in its Modern look: a 3D stone maze on pale sand, viewed at an angle, with Theseus, the Minotaur, relics, a wooden cow and the marble exit arch
    The Modern look today: Chapter 10, a stone labyrinth on pale sand.

    From a quick chase to a puzzle game

    Crete started out crude. The very first draft, on October 8, drew the island in plain text characters: # for walls, E for the exit, @ for you and C for the creature. Within the hour it had switched to emoji, and the first version we kept, on October 9, was an emoji grid on a text page: you moved once, a creature moved twice, and a status panel listed your health and items. It also borrowed its theme from a TV show, which we have since dropped (it’s blurred in the pictures below). A week later the same chase had moved into a proper game frame, with a status bar and a move pad, but it was still emoji on a dark grid.

    That one rule, two steps for every one of yours, was the seed of everything that followed. That same day, October 16, we redesigned the game around the myth of Theseus and the Minotaur and the classic tile puzzle: one move at a time, nothing moves until you do, and the Minotaur always closes the gap if he can. The first build of the new design, a day later, was still rough: eight trial levels on a flat board, with emoji standing in for the tools.

    Today it has a hundred hand-built levels in ten chapters. Each chapter brings in one new piece, teaches it in three short levels, then mixes it with everything before in seven harder ones. The story is told on chapter cards and hidden pages, quoting the old sources word for word from public-domain translations: Plutarch, Ovid, Apollodorus, Catullus and others.

    The very first build of The Island of Crete: a maze drawn in plain text characters on a dark background, with # for walls, dots for floor, a yellow @ for the player, a red C for the creature, an orange E for the exit, blue S for safe zones, purple question marks and green items
    Day one, October 8: the map in plain text.

    The First Week

    From an emoji grid on a text page to the first drawn board. The borrowed TV theme of the first two is blurred.

    October 9: the first version, an emoji grid on a text page with a status panel; its borrowed theme is blurred
    October 16: the same emoji chase in a game frame with a status bar and a move pad; its borrowed theme is blurred
    October 17: the redesign's first drawn board, flat sprites of stone and sand with emoji for the tools

    Two looks, one game

    The first drawn version used sprites rendered in Blender, every one built from a scene written in code, with no outside art. That became Classic. Then came Modern, a 3D board you can turn, tilt and zoom, built from shapes and textures generated in code. Its first version, honestly, was a mess: brown, murky and hard to read. Playtesting on a phone pushed it, in a few days, to grey stone and pale sand, then to crisp edges with no blur, so every piece can be named at a glance on a small screen.

    One Level, Two Weeks

    The same Chapter 1 level, ten moves in, as the look changed from October 20 to today: read left to right, top to bottom.

    October 20: Chapter 1, Level 9 in flat grey sprites, small on a large screen
    October 29: the first 3D look of the same level, brown and murky, seen at an angle
    October 29, later: the same 3D level seen from above, still dark and hard to read
    October 30: the level as grey stone walls on pale sand, readable but soft and hazy
    October 31: crisp, clearer pieces and a compass in the corner
    Today: the same level up close in the Modern look, bronze bars lying over the Daedalus Gate's pit and the Aegean Portal lit blue beside it, after the last relic is taken

    You can swap looks mid-move with the Map button and nothing about your game changes. Classic never loads a 3D engine at all, so it stays light on any computer; Modern is downloaded only when you choose it, and the game falls back to Classic if a device can’t draw 3D. Both share one camera: a compass to turn and tilt, a tap to reset.

    Many small touches came from watching people play. The exit, the Aegean Portal, stays dark until you hold every relic, then light rises up its arch and fills its pool. Bars slide over the Daedalus Gate behind you, and doors sink into the floor as you walk through. The title card is a night scene of the Labyrinth’s entrance, also built and rendered in code.

    The same moment of the same level shown side by side in the Classic sprite look and the Modern 3D look
    The same moment of the same level, in Classic and in Modern.

    The Title Card, Then and Now

    The first title card on October 17, and today's night scene of the Labyrinth's entrance.

    The title card on October 17: a plain text box with Play, Story and Settings buttons on a dark screen
    Today's title card over a night scene of the Labyrinth entrance, with the Minotaur in the lit doorway

    Inside the game

    Under the pictures, the game is a few separate parts that never wait on each other. The screens and menus are small Preact components written in TypeScript. Beneath them sits the rules engine, which knows nothing about the page: every piece is data, and a turn is a pure step from one state to the next, so Undo is simply going back a state.

    Diagram: screens and menus, small Preact components in TypeScript, sit on a rules engine where every piece is data and a turn is a pure step, so Undo is the list of states
    The page and the rules.
    Diagram: background workers run the exact solver and the Endless maker off the main thread; the game installs like an app, plays offline and keeps everything on your device; a shared kit is bundled into each game
    What runs off the page.

    The heavy thinking happens in background workers, off the page, so the board never freezes: one for the exact solver and the editor’s checks, and one that builds your next Endless levels while you play. The game installs like an app, plays offline, and keeps its results, runs and progress on your device. Code shared by all our games lives in a small kit that is bundled into each game when it is built, so every game stands alone.

    Even the music is made this way. The title theme was composed for the game as a score in code and rendered with free orchestral samples: harp, cellos, horn and organ. It streams rather than loading whole, loops with no audible seam, and plays on every screen without restarting; the sound effects are synthesised live in the page.

    Diagram: the title theme is a score written in code and rendered with orchestral samples; it streams, loops with no seam and plays on every screen; sound effects are synthesised live
    How the sound is made.

    A solver at the heart of it

    Every puzzle game has to answer one question: can this level be won? Crete has an exact solver built in. It searches every situation the level can reach (where Theseus and the Minotaur stand, what’s been picked up, which doors are open, where each hazard is) using A* search with a careful estimate of the moves left, and it packs each situation into a few numbers so it can hold millions of them. It proves a level winnable, finds its fewest moves, or proves it can’t be won.

    That solver powers everything players see: the “Best” move count on every level, Ariadne’s thread when you’re stuck, the editor’s Check button, and the Endless generator.

    Ariadne's thread drawn as red arrows across a level, showing the solver's shortest winning route
    Ariadne's thread: the solver's shortest route.
    The level editor with its Check panel listing the fewest moves, situations searched, the Endless rating and the rules that keep the level out of Endless
    The editor's Check: fewest moves, rating, what to fix.

    Rules every level must keep

    Early on, a level could be winnable and still be no fun: the beast walled off from the start, or a door and key you could simply walk past. So every level, whether hand-made or generated, has to pass a gate:

    • The beast must matter. Ignoring the Minotaur and walking straight to the exit has to lose, and he has to stay a live threat for much of the route.
    • No forced catches. You never have to walk into him to win, because no player could know to do that.
    • Every piece has a purpose. Take any piece out, and the level must get longer, change, or become unwinnable. No decoys.
    • A steady climb. Each level is harder than the one before by a set margin. There are no cliffs.
    • Original layouts. No level is a rotated or mirrored copy of another; a test compares every pair.

    Measuring "hard" the way people feel it

    At first, “difficulty” meant how hard the solver had to work. Playtesting showed that’s not what people feel. In Endless, I could put the wooden cow down at once and simply walk past the beast. So we tested it. We wrote simple “habit” players: one that just walks, one that drops the cow on move one, one that raises the mirror whenever he’s close, a careful one that dodges, nine in all. About 29% of the Endless levels of the time fell to one of those habits, and the solver’s effort didn’t predict which.

    That matches the research. Jarušek and Pelánek, studying thousands of human Sokoban solves, found that how much work a computer does to solve a puzzle explains little of how hard people find it. Robert Abbott’s notes on his Theseus and the Minotaur mazes say the same in plain words: what makes a maze hard is its false paths.

    So no level at any setting can be beaten by a habit, and difficulty is scored by things people actually feel: how far the beast forces you off the best path, moves that look wrong but are right, waits, and traps that look safe but can’t be won.

    Diagram: an Endless level is drafted from a seed, solved exactly, put through the gate, scored and placed in a difficulty band, then shared with its recipe; a level that fails the gate sends the generator to the next draft
    Every Endless level goes through the same five steps.

    Levels by hand and by machine

    The campaign’s levels are drawn by hand in the game’s own level editor, and the automated tests hold every one of them to the gate on every change. Endless is made by machine: a seeded generator carves corridor mazes in six different styles, places pieces on their passages, and keeps only the drafts that pass the gate. It comes in Easy, Medium and Hard, each climbing level by level to a plateau, and a run never shows you a maze that looks like one of your last twelve.

    Anyone can build levels too. The editor’s Check runs the same solver and the same gate, shows the fewest moves and the Endless rating, and lists in plain words anything that keeps a level out of Endless. A finished level is shared as a link: the whole level travels inside the link itself, with the solver’s proof that it can be won.

    A shared bank of levels

    A good Endless level can take a couple of minutes to find on a phone. So the game keeps a shared bank: players who choose to help send up the levels their devices make, and every player can draw fresh levels from it at once. The hard part is trust: a person must never be able to sneak in a level drawn by hand, say a maze whose walls spell a word.

    The answer is the recipe. Generation is deterministic, so each level carries the seed, settings and generator version that made it. A new level waits, unserved, until two other devices, one of them on a different network, are handed only the recipe and make exactly the same level, byte for byte. Nothing in a recipe can place a wall, so only levels the generator really made reach players. Only devices whose players said yes do this checking. The game asks once, the first time you start a new game or Endless, whether to Help Build Endless Levels; it stays off until you say yes, and you can change it any time in the menu. Even then it works only while the game sits idle, never during play or on a low battery.

    With few players, a scheduled cloud runner of ours keeps things moving: every six hours it checks the levels waiting in line, then makes new ones where the bank is thinnest, Hard and big boards first. The bank service itself is small on purpose: it only stores and serves levels; all the solving happens on players’ devices and the runner.

    Inside the level bank

    The bank service keeps one store per difficulty, and every change to a store happens one at a time, under a lock: the new copy is written in full beside the old one, then swapped in, so nothing ever reads half a file. Each store has two parts. The waiting list holds up to 300 levels that no player is served, each kept with its recipe, and drops any still waiting after three days. The served pool holds up to 1,500.

    Every arriving level is fingerprinted by its layout, turned and flipped too, so a copy is refused at the door and takes no room. When a new level takes a difficulty past its cap, one served level retires, picked at random but weighted by its age and how often it has been played, so the bank turns over steadily without losing its oldest levels all at once. Two reports from players on different networks retire a level too, and when the generator changes, a whole old version can be retired. Every layout that leaves goes on a retired list that is kept for good, so no level ever comes back.

    Diagram: an uploaded level waits unserved until two other devices whose players opted in, or the scheduled runner, make the identical level from its recipe; then it is served, and turnover retires old levels
    How the bank trusts a level.
    Diagram: inside the bank service, an arriving level is checked and refused if its layout was seen before; it waits in a waiting list of up to 300 per difficulty with its recipe; once made again byte for byte it joins a served pool of up to 1,500 per difficulty; levels that leave through turnover, reports or retired versions go on a retired list kept for good
    What the bank keeps.

    Making levels at scale

    Levels come from three places, all running the same generator and the same gate. On a player’s device it’s opt-in: with Help Build Endless Levels on, a background worker makes and checks levels while the game sits idle, never during play or on a low battery, and sends up each level it makes. With it off, the default, the device sends nothing and checks nothing; it plays levels from the bank first and makes its own only when the bank has none that fits. Either way it keeps up to 150 of its own levels, so it always has something to play offline. The scheduled cloud runner works for about 47 minutes every six hours: it checks the waiting list first, then spends the rest making levels, sharing its time Hard 50%, Medium 30% and Easy 20% among the difficulties with room, and making whatever kind each is shortest of, such as big boards. For a big fill, one command on a workstation makes a set number of new levels per difficulty, under a memory cap that decides how many workers run. It either posts each level as it’s made, or saves them to a folder to look over and upload later.

    Duplicates and retired layouts are skipped and never counted; another level is made in their place. Every run ends with its numbers, levels per hour and seconds per level for each difficulty, so we can see where the time goes and tune it.

    Diagram: levels are made in three places, players' devices that opt in (off by default) making and checking levels in idle time, a scheduled cloud runner every six hours that shares its time Hard 50%, Medium 30% and Easy 20%, and bulk runs on a workstation, all sending levels with their recipes to the bank, which refuses duplicates and retired layouts
    Three places levels are made.
    Diagram: player devices receive checked levels from a small bank service, and those whose players opt in also send it new levels; a scheduled cloud runner checks waiting levels and adds fresh ones every six hours
    Where the work happens.

    How a level reaches you

    Most players get their levels from the bank. Your device keeps a small cache for each difficulty, up to 40 levels, and tops it up when it runs low. Anyone can send levels to the bank, so the device takes none on trust: before playing one, it replays the level’s stored winning line on its own engine and runs the gate’s quick checks, a moment’s work rather than a full search. A level that fails is skipped (and, if you help build levels, reported). With no connection, or nothing that fits, it plays one of its own or makes a new one.

    How changes reach players

    More than a thousand automated tests run on every change: the rules, the solver, the generator, the share links and the bank. Some pin the solver’s exact answers on all 100 campaign levels and every level in the built-in Endless banks, bit for bit, so a change meant only to make the solver faster can’t quietly change a single answer.

    Before anything ships, the whole site runs as a staging copy in containers, and browser tests play the game on phone and desktop screen sizes, in both looks. Only then is a change reviewed and merged, and merging deploys it to production automatically.

    Diagram: a pyramid of checks with over 1,100 unit tests at the base, level gate tests, engine pins on 246 levels, and over 130 browser tests at the top
    The layers of checks.
    Diagram: a change is built on its own branch, tested, rehearsed on a staging copy in containers with browser tests, reviewed and merged, then deployed to production automatically
    From a change to the live game.

    Small decisions that added up

    • Retracing is undo. If you step back to exactly where you were, with nothing else changed, those moves are taken back, so you’re not punished for exploring.
    • Hidden walls are fair. A fake wall opens as you walk through it. An invisible wall shows a faint pane of glass while you stand beside it, and bumping it reveals it for a turn. Levels with hidden walls are tuned a little easier, because the player can’t see what the solver knows.
    • Quiet by design. No pop-ups mid-move; the first time you meet a piece you get one card, after that just a brief banner. This game is about subtlety and a lack of distractions.
    • Phones first. Most of my testing was on a phone. The move pad, the camera gestures and the layout were all reworked from real play on a small screen.

    The result runs on phones, tablets, Windows, Mac and Linux, in the browser or installed like an app, online or off.

    Two phone screenshots: a campaign level in the Modern look, and Demo playing an Endless level by itself
    On a phone: a campaign level, and Demo playing Endless by itself.
    Play The Island of Crete

    All ten chapters, Endless, Demo and the level editor are in the playable demo post, or play full screen.

    Want something like this built for you, or a website, AI or machine learning work? Get in touch with Happy STL.

  • Operation Tankity: Play the Demo

    Operation Tankity: Play the Demo

    Play the demo right here, or open it full screen for the best experience on a phone.

    Play Operation Tankity full screen →

    What it is

    Operation Tankity is artillery in the spirit of the classic Scorched Earth games. Your tank rolls out onto rolling hills against a battery of drones. Set your angle and power, mind the wind, and fire. Every round gets harder, and between rounds you spend your winnings in the shop on bigger guns, armor and parachutes.

    The drones aren’t pushovers. Each one has its own personality: a gambler, a saver, a spotter. They earn and spend money just like you do, and they aim with real physics. Shots arc through the wind, blast the ground away, and anything left hanging over a crater falls.

    Play with friends

    Play solo, or press Play with Friends to open a room and send the link. Up to ten players can share a battle, each taking turns from their own phone or laptop. Long games are supported too: the host can give each turn anywhere from a minute to a week.

    How to play

    • New to it? Press Tutorial. It walks you through the shop and your first shots on the live battlefield.
    • Aim: the arrow buttons or keys change the barrel’s angle and the shot’s power.
    • Drive: move your tank left and right, but driving burns fuel.
    • Fire: the big red button, or the space bar.
    • Initials: pick three letters. They follow you onto the scoreboard and into rooms.

    Want something like this built for you, or a website, AI or machine learning work? Get in touch with Happy STL.

  • The CIC: A Game That Takes Over This Page

    The CIC: A Game That Takes Over This Page

    Welcome back to the blog. This week a small visitor moved in: a scanner eye that watches this page, and a fleet of drones that would very much like to take it apart.

    Press the button below to start The CIC. This page becomes the battlefield. Every word on it is fair game, and when the first nuke lands the letters scatter across your screen. Nothing here is permanent: press Leave and the page comes back exactly as it was.

    How to play

    • Start: press the button, then flip Game On in the top bar.
    • Dodge: on a computer, move the mouse; the eye and the drones track your cursor. On a phone, drag the green reticle with one finger.
    • Fight back: click or tap drones to knock them out. More drones arrive as your count rises.
    • Grenade (G): arm it, then click or tap where you want the blast. Raptor (R): an orbital strike that clears the field and dazes the eye.
    • Survive: you start with 30 HP. Missiles cost 2 each, a nuke ends the run, and ten seconds without a hit heals 1.

    Why put a game on a blog?

    Because it’s fun, and because it shows what a little code can do to a page that was never designed for it. The game loads into this post like any other script, reads the page around it, and turns it into a level.

    Want something like this built for you, or a website, AI or machine learning work? Get in touch with Happy STL.

  • sveltemail: temporary email that cleans up after itself

    sveltemail: temporary email that cleans up after itself

    I got the idea from a YouTube video. Someone was demoing a temporary email service: open the page, get an address, wait for your verification code. It worked fine, but the whole thing was one tab you had to babysit. I figured I could do better.

    The obvious improvement: stop making you come to the inbox. Put it in the browser toolbar. Have it fill in signup forms. Ping you when mail arrives. And while I was at it, fix the part where every temp-mail service keeps a copy of everyone’s mail on its servers.

    So that’s what sveltemail is: a dead drop with end-to-end encryption. Your browser makes its own key when it mints an inbox, and the private half never leaves your machine. What sits on our servers is ciphertext: steal our database tomorrow and you’d walk away with noise. The second your browser gets a message, we delete our copy too.

    Try it right here

    Live demo: this is the real sveltemail inbox, running right inside this post. Mint an address and watch it work.

    Take it with you: the Firefox extension

    If you’d rather have the inbox in your toolbar than in a tab, there’s a Firefox extension now. It mints a fresh address for every form you fill, autofills it in one click, and lets you know when new mail lands.

    Firefox logo Download the extension for Firefox

    v0.1.2 · Signed by Mozilla · Free

    A few other calls I made:

    • No accounts, ever. Your address is a random token with nothing attached to it: there’s nothing to leak.
    • Tracking pixels die at the door. HTML mail gets sanitized before you see it: remote images, scripts, all the exfiltration tricks, stripped out.
    • Inboxes live 5 to 30 minutes: your pick. Timer hits zero: it’s gone.

    What I really want is for this to be easy to reach however you work. The Firefox extension is out now: one-click addresses, form autofill, new-mail notifications right in the toolbar. Chrome and Safari are next.

    It’s free at sveltemail.com. Go burn an inbox.