Moving the games onto Tycho

The record of the move planned in the Tycho plan: what moved in each phase, what changed in each game, and what’s left. Each game did the work on a branch named tycho, kept passing its own tests, and the branches merged into main together when the move was done (October 2026). What’s left for later is at the end.

Phase 0: the repository

• Tyrell’s repository came in with its history, rewritten so every file sits under tyrell/ (so git log tyrell/src/core/world.ts follows it back). Its package, build script and CI were folded into the root’s: one package.json, one version (2.0.0, after Tyrell’s 1.1.0), one build, one CI. The old doctorallen/tyrell repository is left as it was.
• The build makes three libraries (tycho, tyrell, tycho-minds), each as a global script, an ES module and a CommonJS module with declarations, plus the service worker and the test kit, and checks the layers’ rule first. Tyrell’s build is byte for byte what it was apart from its banner and version.
• MIT license.
• The test kit runs on Playwright or on puppeteer-core with $CHROME. The games keep puppeteer-core in their package.json for now (their lockfiles couldn’t be regenerated where this work was done), so CI drives their tests through puppeteer-core and local runs through Playwright, with the same tests.
• CI builds and tests Tycho, then runs each game’s own tests with the new build in place of its vendor/tycho.

Phase 1: the core

• Tycho.seed (hashes, value noise, mulberry32, Lodestar’s Rng, fxRand), Tycho.math, Tycho.color (mixing, shading, the painter’s ramps), Tycho.loop (Stepper for fixed steps, Samples for frame times, Governor for the quality the White Dragon lowers when frames are slow). Each game’s own copies went, and test/core.test.mjs holds each to the game’s original, value for value.
• Each game names what it uses near the top of its first script (const { hash, noise, Rng } = Tycho.seed;), so the rest of its code reads as it did. The golden tests (every level’s shape and painting, the sprites, the pictures) didn’t move.

Phase 2: the shell’s first parts

• Tycho.save: storage that never throws, and a Store for a game’s one save (old keys deleted, renamed ids put right, a save of another version started over, one that can’t be read kept aside). The White Dragon and Lodestar keep their saves on it, under the same keys, so a save from before reads as it did.
• Tycho.pwa: the installable app (a new worker found when the game comes to the foreground and every 15 minutes; then save and reload, or ask). The service worker is dist/tycho-sw.js; each game’s sw.js is a few lines naming what else to keep. Merryfolk became installable with it: a manifest, icons drawn from one of the valley’s trees, the worker, js/pwa.js and test/pwa.js. Opened from a file it still plays as a page.
• Tycho.dev (the query, flags in storage) and Tycho.loader (loading in slices between frames: Lodestar’s loading screen).
• Merryfolk’s save is a Store under its old key (thistledown-save-v2), taking up a save of version 2 with villagers in it. Its renames were a walk over the save renaming whole keys and whole string values; as the Store’s text patterns, each old name is matched as a whole JSON string whose opening quote isn’t escaped ((?<!\\)"cosy"), which is the same thing: 20,000 random saves full of the names, escaped quotes and backslashes came out the same both ways, and a villager’s code from an older game is put right the same way. fresh is an empty object (the game puts each save together afresh from the village, and applies a loaded one by hand: its GAME_FIELDS, registerField and transforms stay the game’s), and keepUnread is off, as an unreadable save was never kept. Its dev drawer’s settings (open or not, the tab, the overlays, the filter) are Flags under merryfolk-dev, merged into the drawer’s own as before.

Phase 3: the renderer

• Tycho.gpu is Lodestar’s GPU design made general: a batcher with a stand-in for the 2D context (Ctx: fillRect, drawImage, alpha, the blend modes, save and restore, transforms, a rect clip, linear and radial gradients), an atlas of every picture drawn, textures for a painted ground, the light map’s multiply, a tint per quad, bloom, and read() for tests. Tycho.light is the White Dragon’s smooth light model, and Tycho.post its blur finish (bloom, reflections, the fade).
• Lodestar’s js/gpu.js is now a thin adapter over it; the White Dragon’s own WebGL path (js/gl.js) went; Merryfolk had none and draws the valley on the GPU for the first time (about 6,800 quads in 3 to 6 draws a frame).
• Each game draws the same frame both ways in a test (test/gpu.js, Lodestar’s test/gllight.js) and holds the GPU to the 2D picture within a few tones; the golden pictures stay the 2D path’s.
• One change a player could see: the White Dragon’s old GL path didn’t dim the neon’s glow by day (its alpha wasn’t premultiplied); the new path dims it as the 2D path always did.

Phase 4: pixels

The games’ shared picture-making, moved in with every picture unchanged. Each part is held to the games’ originals, kept in its test as they were: test/pixels.test.mjs without a browser (the painting itself, through a stand-in canvas), test/audio.js in a page (the canvas work: tinting, flipping, enlarging, outlines on real canvases; npm run test:browser, run by hand, since CI’s build has no browser).

• sprite (sprite.md): canvases (the White Dragon’s canvasOf, Lodestar’s makeCanvas as { read: true, min: 1 }, Merryfolk’s as { read: !draw }), spriteFrom (Lodestar’s; Merryfolk’s is { w: rows[0].length }), outline (Lodestar’s one ink, or Merryfolk’s darkened own colors growing only at need: { own: 0.42, grow: 'edge' }), tinted, flipped, flipSprite, enlarged, Merryfolk’s disc and ellipse, Lodestar’s letter-grid scalers (Scale2x, Scale3x with fixed letters, 1.5x, any k), and the White Dragon’s shape painter as Shapes (its Spr: ell, box, limb, cap, shape, poly, parts with shadow lines, the outline), with the finish’s ink and strengths as a look.
• paint (paint.md): the White Dragon’s chunked lazy painter: the pixel buffer Pix (put, tint, area, block; flat or stroked as an option, where the game had a constant), strokeRow, blockV, operations with boxes and seeds run only for the chunks they touch, the chunk cache (Chunks, Painter: get, ahead within a budget, an optional size with the longest unused let go). Flat, an area no longer works out strokes it never reads: the same pixels, less work.
• fx (fx.md): lists of effects that run out (Lodestar’s tick, the White Dragon’s age), particles (move: drag, gravity, a bounce off the floor; Particles), the White Dragon’s sparks and burst, and where a rising line of text is (rise, its gains).

In the games:

• The White Dragon: Spr is Tycho.sprite.Shapes, flipSprite and canvasOf Tycho’s; paint.js keeps its materials and painters on Tycho’s Pix (a subclass that paints flat) and its chunk cache is a Tycho.paint.Painter; strokeRow and blockV are gone from it. Its life’s puffs and splashes age by Tycho.fx.age, and the HUD’s gains rise by Tycho.fx.rise. Every value in its golden test (every level’s painting, every sprite, the frames) is the same. Its sparks (Fx in player.js) can go onto Tycho.fx.Particles, sparks and burst once that file is free (another branch was working in it).
• Lodestar: makeCanvas, spriteFrom, outlined, tinted, flipped, flippedSprite, artFineCanvas and the letter-grid scalers are Tycho’s; its cast effects tick and move by Tycho.fx. Its painted style (rock, shadows, PntSpr, its pixel buffers) stays its own, as decided. 1880 of its pictures (the Kindler, Wick, every biome’s creatures, the outpost, the nodes, the caches a first frame fills) were compared before and after: all the same.
• Merryfolk: makeCanvas is canvas(w, h, { read: !draw }), spriteFrom is { read: true, w: rows[0].length }, disc and ellipseFill are disc and ellipse, outlineCanvas is outline(c, { own: 0.42, alpha, grow: 'edge' }) and its GPU copy, its critters’ finishSprite is outline(spriteFrom(...), { own: 0.42 }) (always grown), scale2x (under hd()) is enlarged(src, 2, { read: true }) and the wizard’s mirrorCanvas is flipped(src, { read: true }). Its golden sprites and pictures are unchanged, and 312 more pictures (every critter, pet, prop, crop, icon, the wagon both ways, trees and bushes through the seasons, the light pools’ stamps) were compared before and after: all the same. Its villagers’ finer grid with its rings of outline (gridCanvas) stays its own. Its effects (FX, and the wizard’s fireworks) stay its own: they count up to a life with a wait before they start, burst into others as they end (rockets, snowballs), lose speed as drag^(60·dt) rather than e^(-drag·dt), and move in their own order, so Particles and move would change the fireworks. Lantern Night’s sky lanterns age by fx.age (each one’s age counted up, those past their life let go), then drift as before: every lantern’s place and age, frame by frame at three frame rates, the same.

Left in the games, for now: the figures (the White Dragon’s person, whose machinery, the gait and the arms’ bend, is bound up with its looks), the ambient life (each game’s critters, adverts, traffic and litter are its own) and the skyline.

Phase 5: the world

• Tycho.grid, Tycho.collide, Tycho.move and Tycho.path (world.md). The plan’s shapes and space became one part, collide: a Space holds the shapes (boxes, ellipses, the sides, walkways and stairs, ladders) and grids’ tiles, and answers for all of them. test/world.test.mjs holds each to the code it came from, kept in the test: the White Dragon’s on six of its levels as they’re built (test/fixtures/wd-levels.json) and a level made to have ceilings and ledges, Lodestar’s on floors made like its own, Merryfolk’s A* on maps of its kind. Each game also recorded traces from its old code before anything moved (test/traces.js, test/traces.json) and replays them through the new, frame by frame.
• The White Dragon: World.hits, World.way and World.ladderAt ask the level’s space (L.space, made when the level first loads: its solids, the props that block until they’re done, its sides, its walkways and stairs, its ladders), and the runner’s step is a Tycho.move.Platform with T.player’s numbers (the stick, the dev speed and what Use is busy at passed in; taking a ladder lets go of the machine, as before). Its 14 traces (14,574 frames: walls, every pace, hops and jumps, stairs, walkways jumped up through and dropped through, coyote jumps, ladders up, down, jumped off and let go of, long falls, and seeded random input in six places) replay bit for bit. Stayed in the game: Town.route, which is bound to the census and the residents’ minds and will be reworked with them (Tycho.path.Routes is the graph router for that), and the people’s footing (Actors.ground asks the World as before; residents are placed by the clock and the minds, not moved against the level).
• Lodestar: a floor’s tiles and ore are a flat grid over its own arrays (f.grid, made by floorSpace as soon as a floor’s tiles are), and floorTile is its lookup; rockAt is those tiles felt along the smooth line (f.rock, with the floor’s noise), bodyHits and bodyInRock ask the floor’s space (f.space), moveBody is Tycho.move.topdown and floorDistances is Tycho.path.distances. The one tile changed in play (a storm charging a vein) is set through the grid. Generation’s golden hashes are unchanged; its 18 traces (8,688 frames on the surface, the Deep and a ruin, bodies of 4, 6 and 9 px walked into walls eight ways, round curves, wandering and dashing, worked out of a wedge) and its probes (the wall line on both its tables, the body test on a lattice, flow fields from five caverns) replay bit for bit. Stayed in the game: clearLine, the enemies’ sight, sampled every 4 px through square tiles (space.ray is exact, so it would change what they see), and wayToPlayer, the enemies’ own eight-way reading of the flow field.
• path.distances stays inside the grid where Lodestar’s went round to the next row at the left and right edges; that never mattered, as its edge is always solid rock.
• Merryfolk: findPath and nearestWalkable ask a Tycho.path.AStar the size of the map (PF, remade by setMapSize with the cap scaled to it), the game giving walkable and each step’s cost (stepCost: the ground’s own and a terrace bank’s climb). 6,000 paths over four valleys (three classic, one planned and larger) and half a day of a village (every villager where they were, the minds’ hash and the save byte for byte) are the same before and after; on the same queries in Node the A* is about a fifth quicker (swaps without destructuring). Its map arrays stay plain arrays: they’re written straight in some eighty places by generation, building and terraforming, the ground is repainted where a change asks for it (repaintRect), and nothing is saved by tile, so a grid over them would be a wrapper nothing reads through.
• Speed, measured in Node by CPU time on a 320 × 320 floor: the wall line 102 ms against the game’s 131 for the same points, the body test 27 against 30, ten flow fields over open ground 28 against 62 (a flat grid reads the game’s arrays straight; the field’s queue is kept between searches).
• Not yet: gen, liquid and tilelight; a big grid’s chunks let go of and made again (its changes are kept by chunk for that); and no game saves a grid’s changes yet (Lodestar’s world is made whole from its seed and keeps nothing of its tiles in a save).

Phase 6: play (input, items, guide)

• input (play.md): Controls, the controls both games had as one configured part: actions held by keys, on-screen buttons and the bot; presses that wait to be taken (the White Dragon’s useHit/jumpHit, Lodestar’s consumeAct/consumeDash); edges since the game last looked (Lodestar’s hand); the stick (the White Dragon’s square with a dead zone each axis and a second thumb taking over, Lodestar’s round one kept inside the deck, with its flick); blocking new presses while a screen is up, letting go of everything when one opens (block), and the tap guard (Lodestar’s 400 ms). Gestures: drag, pinch and tap for the maps (the White Dragon’s two maps, which shared their code, and Lodestar’s), with each game’s tap rule and pinch by options. test/play.test.mjs plays each game’s old controls and gestures and its new ones side by side with the same events.
• items: bags by count (the White Dragon’s pockets, Lodestar’s motes carried and banked), things of their own with ids (the White Dragon’s parts), slots, gear, and group, the counted view under the White Dragon’s shelf and the bench’s choices. Their words, prices and HTML stay the games’.
• guide: the White Dragon’s tutorial step machine; its steps, card, marks and pulsing stay the game’s.
• Changed in the White Dragon: input.js is a thin Input over Tycho’s controls, refreshed each step by apply(); the maps’ drag and pinch are Tycho’s gestures (the wheel is still the game’s); Game’s pockets, the salvage sums and the scrap bin use items.bag; Parts.make/take/have use items.things and Parts.stock/choices items.group; Tutorial runs on a guide.
• Changed in Lodestar: input.js is a thin Input over Tycho’s controls, and the screens’ tap guard is the controls’ (Input.guard, Input.guarded, from UI.show, a confirm button arming and the map’s tap); the map’s drag, pinch and tap are Tycho’s gestures; the motes carried (d.motes) are a bag. Its equipment (Save.data.equip: one rig, never changed or saved) and the unused d.cargo stayed as they were: neither is an inventory any more.
• Changed in Merryfolk: the camera’s keys (WASD and the arrows) are a Controls with keys and axes only, fed the keys’ names by its own listener (which keeps its shortcuts and leaves typing in a field alone; listen would read codes, so a keyboard laid out otherwise would move differently), and the wizard’s pack is counted and given from with items.bag. Its pointer stays its own: past six pixels a drag picks up the villager under it (the giant hand) or pans by its whole offset from where it landed, a pinch zooms in whole steps from where it began (its distance floored at 20) about the spot first under the fingers, for touches only and never while carrying, and the mouse hovers; Gestures pans and pinches by steps between moves, so it would change all of that. A home’s pantry is counted by kind too, but it isn’t carried and is written in many places with keys made as it goes, so it stays as it is.
• Where the games’ own controls disagreed with themselves, Tycho’s do the plainer thing, the same in both games: two keys for one action (the White Dragon let go of the action when either came up), two fingers on one button (it let go when either lifted), keys and thumbs at once (the last to speak won), a third finger on a map (it panned) and a finger the browser cancelled on a map (it stayed down). None of these comes up playing on one device.

Phase 7: the rest of the shell (audio, inspect, ui)

• audio (audio.md): Lodestar’s sound engine, made general: Engine (the graph: two buses with sends to an echo, the chain and the limiter; the settings as levels; cues by name with gaps, a cap on voices, distance and pan from a listener; the first tap and the hidden page), the voices (tone, noise, fm, stack, env), Bank (sounds rendered ahead in an OfflineAudioContext, variants, the saturation and the reverb’s impulse, a start paced by a loader’s slices, idle rendering, want and drop) and Music (drones kept running, noise bands, targets set only when they change, a tick of its own, events now and then, the dip), all drawing from one stream of the sound’s own (Rand, Lodestar’s xorshift). Every number that makes Lodestar sound like itself is passed in by Lodestar (its cues, its bank’s recipes and order, its waves, its chain, space, reverbs and trim); Tycho’s defaults are the same numbers. test/audio.js traces every Web Audio call Lodestar’s sound makes before and after (44,615 of them across 68 cases) and they’re the same call for call; the samples agree to Chromium’s own rounding. CI’s build job now runs it, with Chrome and puppeteer-core.
• inspect (inspect.md): the White Dragon’s Tyrell mode as Inspector (the bar, the clock and its time walk, the canvas the game draws its map on with dot and badge, the side) and mind(world, id, options) (the mind alone, as HTML). It reads the world through the shape of Tyrell’s World, so the shell takes nothing from tyrell/src. test/inspect.test.mjs holds the mind to the game’s original on Rocinante, character for character.
• ui (ui.md): Toasts (the White Dragon’s short list on game time, redrawn whole, the same words again soon keeping the last one up; Lodestar’s elements on their own timers, the same words giving way to the new, hints queued while a screen’s open and never shown twice), Rising (the White Dragon’s lines over a machine: the list and its HTML, moving by the pixels’ fx.rise), bind (buttons by their data attributes: the White Dragon’s panelBind) and Acts (a screen’s buttons from one handler: Lodestar’s UI.onTap, with its confirming tap). test/ui.test.mjs plays each game’s original beside Tycho’s, step for step, on a stand-in for the DOM. Blocking taps after a screen opens is the controls’ guard (phase 6, Tycho.input), which Acts takes as its guard.
• Stayed in the games: the HUD itself (what each shows, and where: the White Dragon’s money, heat, prompt and bubbles over heads, Lodestar’s bar, deck and speech) and the maps (the White Dragon’s pause map and city map, Lodestar’s map by layer): their looks and what they show are each game’s, and the shared parts of them are in already (the maps’ drag, pinch and tap are Tycho.input’s gestures).
• For Merryfolk, later: its sound (buses, a reverb, a tone helper, the rain’s bed, sleeping while hidden) fits Engine, the voices and Music’s bands, with its look-ahead tune its own; its single toast is Toasts with most: 1; its Brain tab becomes inspect.mind once its folk are on Tyrell (phase 9).
• Changed in Lodestar: js/audio.js keeps the mix, the chain’s and the space’s numbers, the waves and the cues, and makes Snd a Tycho engine (snd, sndReady and the first tap through it); js/music.js keeps its layers, phrases, beds and events and the music’s own logic (state, update, phrase, bed, fed, grow, listen) on a Tycho Music; js/sndbank.js keeps its layers (bkSub, bkPings, bkGrains, bkSnap), elements, Forms, footsteps, opening and order, with SndBank a Tycho bank. The smoke test now checks the sound starts on the tap, with the bank rendered while the game loaded.
• Changed in Lodestar, ui: UI.toast, showToast, pumpToasts and UI.show’s hints are a Tycho Toasts (UI.toasts); the words, the classes and the CSS that fades them are the game’s. UI.onTap is a Tycho Acts (UI.buttons) on UI.acts, with the controls’ guard (Input.guarded()), the confirming tap’s moment of guard (Input.guard(0.25)) and the tap’s sound; it moved after phase 6’s controls were merged, since both changed those lines.
• Changed in the White Dragon, ui: Game.toast and Game.gain go to the HUD’s Toasts and Rising (Hud.toaster, Hud.rising), and panelBind wires its buttons with Tycho.ui.bind.
• Changed in the White Dragon: js/tyrellmode.js is its map (the city’s rows, a street’s picture with its doors’ counts, where everyone is, the summary) on Tycho’s inspector, which draws the mind, runs the clock and wires the panel. The panel, the mind and the map are the same as before, pixel for pixel and character for character (compared step by step in a browser).

Phase 8: Tyrell’s new parts

• Voice (conversations), Delos (genomes inherited through births), skills that grow with practice, Athelas (conditions that run a course), pastimes that pall and wishes that pull, and production in Ceres. A test holds that a world using none of them is byte for byte what it was.
• The White Dragon’s talk moved onto Voice (js/talk.js): what’s theirs raised first (what they saw, what they heard, a job, a hand-back, a lead), then subjects, each answer with an approach that lands well or badly by the listener. The smoke test takes Ozzy’s job through it.
• Every number that shapes the minds is a setting the game can change (175 of them, tuning.md): each module’s config, and the core’s, with plain headline knobs that scale a whole behavior (friendship, romance, breaks, forgetting, gossip, reporting, chatter, courtship, births, contagion…), each 1 by default and exact at 1, so a world that sets nothing is byte for byte what it was (Rocinante’s week, Voight-Kampff, Merryfolk’s minds and the White Dragon’s smoke run all unchanged). A person’s definition can carry their own headline knobs (tune), and world.tune(module, values, person?) changes settings in play as a recorded input, kept in the state, so time walk replays it and a save keeps it.

Phase 9: Merryfolk’s minds

• Merryfolk’s villagers run on Tyrell (js/shell.js, its shell): needs (Bicameral, each villager’s rates from genes, age, trade, illness, ale and the season), the choice (every reason the old score gave reaches it through the game’s module), genes (Delos), births, couples and parents (Cradle), skills, work rounds (Mentat), the Common Store (Ceres), feelings and memories (Reverie), regard and friendships (Fellowship), chance (Tyrell’s streams), the wizard’s talks (Voice). The game’s old fields are views over Tyrell’s state. Space stays the game’s, and so do imitation, the body (ale, germs, toxins), breaks, wishes and pastimes; time walk is off.
• Compared before and after (node test/season.js, test/minds.md): folk are hardly ever famished now (an urgent need breaks in), happier, break far less and make more in about the same hours. The first move had friendships form more slowly; a second look found most of the gap was seed-to-seed noise and the rest habits learned by Tyrell’s rule rather than the game’s: the game’s rule is back (through reward, Tyrell’s own learning off by its habits setting), and a year’s friendships, weddings and births are at or above the old village’s again. Over six seeds without the wizard there’s still about a fifth less time in company, because needs sit lower all day.
• About twice as slow at first; a fifth of that back (the shell’s views cached, and each moment thought over once, checksOnce).

Phase 10: the bridge

• dist/tycho-minds.js (Tycho.minds, minds.md): the clock (the game’s time driving Tyrell’s, back through time walk, remade past what Esper remembers), the minds in the save, seats, presence (who might be in a level, once per doing), travel times, witnesses and reports. It takes only shapes from Tyrell, so it builds and tests on its own.
• The White Dragon’s city.js uses all of it; what stayed in the game is its own: the census, routines, the route on screen, the reactions’ words.

After the move

• Interactions between people are Bree, a Tyrell module (bree.md): exchanges that land from warm to a row, words that turn into arguments and fights (stopped by patience or someone stepping in), grudges and feuds that last and fade, avoidance, making up, and conversations topic by topic round a table. It’s inert until a game declares kinds; next, Merryfolk’s natters and quarrels and the White Dragon’s greetings and small talk move onto it.
• Harm between characters (fights, weapons, spells, traps, poison, accidents) is in harm.md: Lodestar’s fighting moved into Tycho.harm bit for bit, held to a test of 32 fights recorded before the move, and Morgul, a Tyrell module, carries the wounds, fear, grudges, blame and crimes that follow. Next, the bridge between them and Merryfolk’s scuffles and pranks; the White Dragon takes none for now.
• The dev tools have a drawer (dev.md): Merryfolk’s dev drawer (its key and button, docked at the side while the game runs, tabs refreshed a few times a second without losing your place, the overlays row and the frame line, the events by kind) made for any game, with the pieces every tab shows (bars, tables, steppers, toggles, choices), a tag while a setting that changes play is off its default, a tap on the game picking someone, and a canvas for the overlays. The White Dragon’s dev menu and its slider are gone for it (Mind, Events, World and Tools, with Tyrell mode’s city map opened from it). Merryfolk moves onto it after its harm work; every feature of its drawer is reachable through the drawer’s options.
• Parts planned for the games to come (a Terraria-like crafting game): gen, liquid and tilelight in the world; interact, craft, trade, build and mine in play; a big world’s chunks let go of and made again, and its changes saved.
• What stays in each game by design: figures, ambient life and skylines; Lodestar’s painted rock; the HUDs and maps; Merryfolk’s pointer gestures, particles and the villagers’ outline; the White Dragon’s routes for its residents.