▶ dreamengine

The whole 3D pipeline, shrunk to one spinning textured square: a point in space, rotated, projected to the screen, then textured with two triangles -- plus the warp that trick causes, and the subdivision fix. Every 3D cart in this engine (cube3d, solid3d, textured3d) is this same loop run over more points: ROTATE each 3D corner with rot3(), PROJECT it down to a 2D screen position with project3(), then FILL the shape -- here with tritex(), which paints a triangle by mapping its 3 screen corners to 3 pixels on the sprite sheet. A quad is just two triangles sharing a diagonal, so tritex() gets called twice -- and because each triangle is mapped independently in screen space (no perspective correction), the texture creases along that diagonal as the quad turns. Press X to chop the quad into a finer grid of smaller triangles: each one warps less, so the crease melts away. left/right: spin speed. up/down: tilt (pitch). Z: wireframe overlay. X: subdivision level

acid rack ⚡2×audio

Two 303s, the full 909, the curated 808 and per-device FX in one cart — and a SONG CODE: 8 hex characters that generate a whole arranged acid track (banks A-D + the chain), ready to edit while it plays, then export as WAV. The RB-338 homage, increment 2: two full TB-303 voices (the engine's FILTER_DIODE diode-ladder squelch, authentic non-retriggering slide, accent into the filter env, live CUT/RES/DRV knobs per machine) + the COMPLETE tr909 kit (11 voices — analog kick/snare/toms/rim/clap, FM-clang metal, the stroke family: right-click a cell for flam/drag/ratchet, the METAL-FILTER XY pad riding all five metal highpasses, TOTAL ACCENT row) + the curated tr808 (9 voices: boom kick, snare, 2 toms, clap, maracas, cowbell, hats — congas/clave/rim/cymbal cut per the rack slot budget), all clocked off one transport with the 909's period-correct even-16th SHUFFLE (one master knob + Z/X). Effects are PER-DEVICE like the real RB-338: every machine strip has an [fx] view (the header button swaps the grid for that machine's effects) with DIST (per-voice drive on that machine only — drums scream while the rest stays clean) and SEND (its level into THE one shared tempo-synced delay unit, per-device routing like the hardware; the 909's fx view also hosts the METAL pad and SHUFFLE). The MASTER strip keeps what genuinely needs a bus: the delay unit's TIME (snaps 1/16, 1/8, dotted-8th, 1/4) and FB, GLU (the glue compressor that tames the drop), and the PCF: a pattern-controlled filter whose 16-step level lane is drawn per BANK, so the arrangement itself rides the master lowpass — the demo's build bank is literally a drawn ramp that opens the filter over one bar. (True per-device PCF/comp waits on machine buses — effects-bus-architecture.md Increment G.) The rack is an ACCORDION: each machine is a slim strip showing its name, a live 16-tick mini pattern with the playhead, and a MUTE — tap a strip to expand its full editor (piano roll + flag rows + knobs for a 303, trigger grid for the drums). Sound never depends on what's open. Patterns live in four BANKS (A-D, the transport buttons); the SONG row at the bottom chains up to 64 bars of banks into a real track — tap a cell to cycle A→B→C→D→empty. Everything autosaves. SPACE run/stop · tap a strip header to expand · A-D buttons pick the edit bank (also LEFT/RIGHT) · SONG button toggles chain playback · tap SONG-row cells to write the arrangement · UP/DOWN tempo · Z/X shuffle · roll: tap/drag paints notes, tap a note to erase · OCT/ACC/SLD rows toggle per step · drums: tap cells, right-click a 909 cell for flam/drag/ratchet, AC row = accent, drag the METAL pad for hat tone · MASTER strip: GEN new song code (also G), tap code digits to nudge, [ ] history, WAV = export the arrangement · drum grids: per-voice TUNE/DEC/CHAR mini-knobs beside the rows (drag up=coarse right=fine, rclick=reset) · [fx] button on a machine strip: its DIST + delay SEND (909: also METAL pad + SHUF) · MASTER strip: delay TIME/FB, GLU, PCF/RES + drag the lane to draw the filter pattern · CPY/CLR/RND act on WHAT'S OPEN: a machine strip = just its lane of the edit bank, MASTER = the whole bank (CPY arms — tap the target bank to paste)

delia ⚡2×audio

Five tape loops of DIFFERENT lengths phasing against each other - rhythm the way Delia Derbyshire actually made it. No two bars ever quite repeat. A concrete tape-kit: each lane is its own loop with its own length (16-step thud against a 5-step ring-modded lampshade against 7-step BBC pips against 11-step splice clicks against a 32-step reversed swell). All lanes tick at the same sixteenth-note rate but wrap at different points, so the playheads visibly drift apart and realign - the polymetry IS the interface. Voices are musique-concrete recipes: a dead damped thud, a struck bar through a ring modulator (carrier on the RING knob), 1kHz time pips (step 0 of the pips loop is the LONG pip, like the real ones), filtered noise splice-ticks, and a slow-attack noise swell cut dead - the backwards-tape cymbal. Each seed also bakes constant per-step micro-offsets (identical every cycle - a physical splice, not humanize). WOW/FLUT ride the master tape so the whole groove breathes. SPACE run/stop . tap cells to toggle (drag paints) . tap a lane name to audition . M box mutes . < > beside a row change its loop length . [ ] previous/next seed . UP/DOWN tempo . knobs: RING (lampshade carrier) WOW FLUT (tape) . keys 1-5 fire the voices

mixing booth ⚡2×audio

A tiny 6-track band loops itself so both hands are free to flip each track's OWN private effect on and off -- proof that instrument_tape()/instrument_gate()/instrument_ringmod()/instrument_univibe()/instrument_shallow()/instrument_grains_freeze()/instrument_grains_pitch()/instrument_fx_mod() touch only the one instrument slot they're given, never the rest of the mix. Six channel strips, one per track (DRUMS/BASS/LEAD/ORGAN/PAD/GTR), each wired to a different per-instrument effect nobody else in the library demos: DRUMS gets instrument_tape() (wow/flutter/saturation), BASS gets instrument_gate() (choppy noise-gate chop), LEAD gets instrument_ringmod() (a metallic carrier), ORGAN gets instrument_univibe() (the liquid photocell wobble), PAD cycles OFF -> WARP (instrument_shallow) -> FREEZE (instrument_grains_freeze + instrument_grains_pitch, a frozen granular drone), and GTR retrofits the underused ampcab.h guitar-amp bundle (5 voicings via instrument_drive/instrument_drive_mode/instrument_eq/glue) plus a BREATHE toggle that rides instrument_fx_mod(FXMOD_DRIVE) every frame for a slow gain pulse. The guitar re-strums each chord change via strum_notes() -- an explicit 3-note array, not a CHORD_* type. Each strip's AMOUNT knob controls its effect's main parameter; MUTE/SOLO isolate a track so the 'clean everywhere else' claim is audible, not just asserted. Every instrument_* call is SET-AND-HOLD -- it only fires on the button/knob that actually changed, never every frame. tap a track's switch to cycle its effect (off/on, or off/WARP/FREEZE for PAD); drag/wheel the AMOUNT knob under it; MUTE/SOLO isolate one track's effect

ota family ⚡2×audio

A singing family of four otamatones - daddy, mommy, junior and the dog - each with its own voice, plus a live-looper so the whole household ends up singing rounds together. Four otamatones drawn as a family, each a drag-to-play fretless ribbon with its OWN character: DADDY sings low and slow (lazy 90ms glide, dark muffled mouth, slow wide vibrato), MOMMY mid and graceful, JUNIOR high and jumpy (22ms glide, thin bright buzz, eager fast vibrato), and the DOG doesn't really sing - a raspy driven growl (asymmetric fuzz after the resonant filter) with a breathy noise CHUFF on every attack: press = WOOF (the note starts +6 semitones and drops), holding turns it into a HOWL that drifts sharp with a huge wobble, and it's permanently a little out of tune. Wiggle sideways off the ribbon to open each mouth (a resonant-filter wah - the faces' pixel mouths open to match). The LOOP: arm a member with its REC button and everything you play on it - the continuous pitch/mouth gesture, not quantized notes - records into a shared 8-beat tape loop and replays verbatim as a ghost dot on the ribbon while you layer the next family member on top. Two step-sequencer rows (BOOM/TICK) run underneath for rhythm, delia-style tap cells. The loop bar up top shows every member's recorded gestures as colored dots. drag a stem to play (multitouch: one finger per family member) . wiggle sideways = open the mouth . REC arms that member's loop, X clears it, M mutes . tap BOOM/TICK cells for rhythm . 1-4 = a little yip from each member . UP/DOWN tempo

session desk ⚡2×audio

The yacht radio opened up on the producer's desk: the CHORD CHART is the star. Type the radio's 8-hex song code and the exact tune lands as an editable chart - tap the mu chords, reorder the form, edit the drum skeleton and the sax hook - while the session band keeps playing it like players, not a sequencer. The first chord-first tinyjam rack. The truth is a CHART, not a piano roll: a 4-slot chord row in the yacht idiom (mu / maj7 / m9 / 13 / 9sus - tap to reharmonize while it plays, arrows nudge the root, MU-IFY and SUS-MELT run the radio's own flavor rolls), an 8-slot FORM row (intro/verse/chorus/bridge/outro, tap to rearrange; GEAR arms the +2 truck-driver lift on the last chorus), a 5-lane drum SKELETON grid, and the sax hook as a 32-step cell lane. Everything else stays a PLAYER: the bass walks chromatic approach runs INTO whatever chord you just tapped in (RUNS knob), the FM epiano voice-leads its mu voicings and pushes the and-of-4 anticipation (ANTIC), ghost snares and the Purdie swing live on knobs (GHOST/SWING), the sax picks its own chord tones through your cell rhythm, a little behind the beat (LAID). Three DRUMMER chairs (session 16ths / Purdie half-time shuffle / CR-78 circuits) swap the kit voices and feel defaults; RECHART rewrites the skeleton in that drummer's hand. THE BAND rows swap the epiano/bass/lead/pad chairs live, same recipes as the radio. The 8-hex SONG CODE on the transport is the radio handoff: the generator is yacht.c's new_song verbatim, so a code seen on the yacht radio dial reproduces that exact song here, opened up for editing. Autosaves; WAV export via the engine's live capture. SPACE play/stop · SONG/LOOP toggles the form vs looping the chord row · UP/DOWN tempo · chord row: tap a cell to cycle its quality, tap the cell's arrows to nudge the root, KEY cycles the key · MU-IFY/SUS-MELT melt chords like the generator does · form row: tap a slot to cycle the section, GEAR arms the last-chorus lift · DRUMS: tap cells (off/on/accent), drummer buttons swap the kit's hands, RECHART rewrites the skeleton, GHOST/SWING/FILL knobs set the feel · HOOK: tap the 32-step sax cell, REG moves the register, LAID drags it behind the beat · BAND: tap a candidate to swap a chair, MUTE per player · DESK: NEW rolls a song code (also G), [ ] history, tap code digits to nudge, WAV exports, TONE/FEEL as on the radio, RUNS/ANTIC/STAB set the players' feel

tracker ⚡2×audio

A real music tracker: phrases of 16 steps chain into songs, four tracks, mnemonic FX — the LSDJ/M8 model on a 40-column screen. Four independent tracks each walk a column of CHAINS; a chain strings PHRASES together with per-entry transpose (one bassline serves every chord); a phrase is 16 steps of note + instrument + one FX command (ARP POR VIB VOL CUT PAN RET DEL HOP TPO). Eight hand-tuned presets — lead, bass, bell, pluck, pad, kick, snare, hat — so drums and melody interleave on any track. A demo song is loaded on first boot; your edits autosave. Press R to ROLL A RANDOM SONG (B hops genre: CHIP, HOUSE, HIPHOP, DNB) — it rewrites the same phrase/chain slots every time, so you can flip through the views and read how each genre builds its groove. TAB or [ ] switch view · arrows move · type notes on A–L / W–P (Z/X octave) · ENTER drill in / place · -/= nudge, ,/. big nudge · Q note-off · BACKSPACE clear · C/V copy paste · SPACE play/stop · 1/2 tempo · R random song · B genre

10b. camera and clip

Pan a raw camera() by hand over a world bigger than the screen, and clip() a second view into a corner window. 10-world's camera follows the player via follow() — a convenience wrapper. Here: camera(x, y) is driven directly by input to show what it actually does (shift everything drawn by -x,-y), camera(0,0) resets it before drawing a screen-fixed HUD, and clip(x,y,w,h) restricts drawing to a rect — used to pin an independent, differently-positioned view of the same world into a corner (a minimap/inset window). arrows/dpad pan the camera

23. variables, conditionals, loops

The C basics every tutorial has used silently since cart 3, taught explicitly: int/float/bool, if/else, for/while. left/right change page; up/down adjust each page's live value; Z toggles rain on page 2

24. functions, arrays, structs

Writing your own functions, a fixed array you loop over, and a struct that bundles fields into one value. left/right change page; up/down adjust; A/B move the cursor on pages 2 and 3

25. entity pool and friendly state

The engine's two signature idioms: a fixed entity pool with an on/off flag, and STATE{}/S-> sugar over de_state(). left/right change page; A spawns/scores, B kills/loses a life

6b. chords and rhythm

Stack chords from a scale and gate a hi-hat with a Euclidean rhythm. degree(scale, octave, n) picks a chord ROOT from a scale degree; chord()/strum() stack a triad on it (strum staggers the notes into a tiny arpeggio), voiced on the engine's real StifKarp grand piano. euclid(hits, steps, b) spreads hits as evenly as possible across steps — the same algorithm behind claves and tresillo — gating a filtered-noise hi-hat under a I-IV-V-vi progression. left/right arrows change the hi-hat's euclid density

touch controls testbench

A dev test-bench for docs/design/touch-controls.md — every touch_layout() move mode, live btn() readout, and a touch_debug() overlay showing the band/grab-zone and placement. Press 1-4 to switch the on-screen control between floating analog, fixed analog, 4-way d-pad, and 8-way d-pad. Drag the control (mouse-as-touch on desktop) or use the keyboard to drive it; the read-out shows exactly what btn() sees. touch_debug(true) is always on here, drawing the control band outline (cyan) and the current move mode's grab zone (magenta) — the stick's rectangular zone, or the d-pad's local circular radius — plus the placement mode and touch_ctrl_scale() as text. Run with DE_WINDOW=640x900 to see DECK placement, or DE_WINDOW=900x400 to see RAILS (default window == game, so OVERLAY, is what you get without it). 1/2/3/4 = analog / analog-fixed / dpad4 / dpad8 · drag the pad, or arrows + Z/X · DE_WINDOW=WxH env var to preview deck/rails

touch vocabulary

Reference cart for docs/design/touch-controls.md's Layout vocabulary table - cycles through every SHIPPED touch_layout() scheme over a mock game scene, so each row can be baked as one clean image (deck/rails/overlay previewed via DE_WINDOW). Unlike touchpad.c (a hand-mocked pixel-art impression that predates the real API), this cart calls the real touch_layout() for each row, so a bake is the actual engine widget, not an artist's guess. Cycle order matches the vocabulary table: single floating stick (0 buttons), analog + A/B (2), d-pad + A/B (2), d-pad8 + 3. Twin-stick and buttons-only aren't implemented yet (no second move slot, no TOUCH_NONE), so they're not in the cycle - see the doc's Open Questions. Run plain for OVERLAY (matched aspect, the default), DE_WINDOW=640x900 for DECK, or DE_WINDOW=900x400 for RAILS. SPACE = next scheme · arrows move, Z/X/C/V = A/B/X/Y · DE_WINDOW=WxH env var previews deck/rails · DE_SCHEME=n picks the starting row (0-3), for scripted bakes

citydrive

Drive a REAL city in pseudo-3D. citydrive loads the SAME OpenStreetMap data as roadview (a .rvb fetched by data-tools/roadview/osm-roads.js) but instead of drawing it flat top-down, it EXTRUDES every building footprint straight up the screen — GTA1-meets-Zelda, the cityview look applied to real geometry. Footprints are arbitrary OSM polygons (not boxes), extruded with winding-based wall culling + polyfill roof caps; heights come from the RVB2 format (OSM height / building:levels tags, ~6% coverage, with a per-footprint fallback for the untagged majority). Roads draw as flat ground ribbons in the real road hierarchy, over a ground of flat area fills — blue water, green parks/woods, peach sand, and muted developed-land/zoning — so the city isn't bare between buildings. If the data carries a terrain heightfield (fetch with osm-roads --dem, e.g. San Francisco's hills or a fjord/lake like Konigssee), the whole scene DRAPES over a shaded low-poly hillside — roads, footprints and the car all ride the real elevation (exaggeration auto-scales so 138 m city hills and 1200 m mountain walls both read). It needn't be a city: a nature bbox renders as water + forest + mountains (forest dithers so the shaded slopes show through), and you can zoom right out to take in a whole landscape. You spawn in the dense building mass (robust against the OSM bbox-balloon). V flattens the whole thing to a top-down 2D map (handy to check that footprints sit beside roads, not on them). Opens on data/demo.rvb; DRAG any .rvb/.json from the data folder onto the window to load that town, or OPEN reveals the folder. Arrows/WASD drive; M cycles the CAMERA — north-up / heading-up / a real pitched PERSPECTIVE (pinhole, perspective divide → horizon + foreshortening; with terrain, mountains rise against the skyline), with live ,/. pitch and ;/' eye tuning; V top-down map, T textures, R toggles roads, [ ] zoom. Roads are drawn geometry-first: one connected asphalt surface whose WIDTH comes from OSM (width tag / lane count / class, with one-way carriageways narrowed so their freed space becomes a wider pavement), light pavement/kerb bands, OSM-driven lane markings (N-1 dashed dividers from the real lane count; one-way streets drop the centre-line), and — from an in-cart junction graph — give-way haaientanden on the minor approach of each priority-controlled crossing (the bigger road keeps voorrang), and real zebra crossings at OSM crossing nodes; separate cycleways render as red Dutch fietspaden, and on-road bike lanes as a red fietsstrook along the carriageway edge. P/L/G toggle pavement / lane-markings / give-way independently (fine detail fades when you zoom far out).

added 2026-06-30

Squishy Lines

Draw with a velocity-sensitive ink brush — lines swell when you go slow, thin out when you go fast, and taper to a point at each end. Pick a tool, thickness, and bevel in the top panel. Every stroke is stored as DATA (a path of points + the speed you drew each one at), not painted straight to pixels. Most brushes render that path as a chain of overlapping round stamps whose width = a slow→fat / fast→thin speed curve × an end-taper × a little seeded wobble — ink / pencil / fineliner / marker / chalk are different sets of those numbers (chalk drops stamps for a dry, broken grain). Six brushes render specially: SKETCH (a hairy web of threads, à la Krita's Sketch engine), SPRAY (an airbrush dot-cloud whose spread follows speed), BRISTLE (raked parallel hairs), PAINT (a wide wet brush whose paint runs DOWN in drips from every exposed bottom edge of the stroke — so a serpentine drips off each of its bands, not just the lowest; a run stops when it meets paint below, so inner bands make short runs into the gaps and only the open bottom edge falls long. Run length ∝ the band's thickness. Still a pure function of path+seed, no simulation. It also takes BEVEL for a raised glossy edge; boil wobbles the wet body but the runs stay put — they're 'dried', computed from the stable path), and NIB (a flat calligraphy nib held at a fixed angle: width comes from the ANGLE between the stroke and the nib, not speed — a hairline when you move along the nib, full width across it, so you get true broad-nib thick/thins. Rotate the nib angle with [ and ]; each stroke keeps the angle it was drawn at. The nib is a FAMILY of four sharing one renderer that reads an angle recipe: NIB (fixed angle), BRUSHPEN (angle PLUS a speed swell — swells slow, thins fast), REED (a dry pen whose angle chatters per point, seeded so it's a stable texture that still boils), and TWIST (the angle winds along the stroke); the rim/fill features all take the true nib-ribbon shape), and OIL (thick impasto paint faked for the limited palette: an auto-bevel rim gives the raised, light-catching edge and raked highlight/shadow streaks along the drag read as the ridges and grooves of paint pushed by a knife). OUTLINE draws a fatter silhouette in its own colour UNDER the fill — a black rim + coloured fill is the chunky bubble-lettering look (draw with the fat ink brush, add bevel for a highlight, and you're at the Tiny-Jam logo). BEVEL embosses a stroke into a faux-3D rim; the light is a GLOBAL 'sun' set from an on-screen SUN popover (drag the dial to aim it, tap one of four colours warm peach → golden → neutral → cool moon, toggle auto-spin) or from the keyboard (, and . rotate, / recolours, \ auto-rotates); every beveled stroke (and the oil-paint rim) relights together, so you sweep and recolour the sun across the whole drawing; BOIL brings a stroke alive in one of two styles (the boil button cycles off → wobble → pulse): WOBBLE = per-point hand-drawn jitter cycling ~7.5fps; PULSE = a subtle smooth grow/shrink breath about the stroke's centre. Almost free since rendering is a pure function of (stroke, seed). Bevel + boil are PER-STROKE — each stroke captures the toggle state when you draw it, so some strokes can be beveled or boiling and others still; the toolbar toggles set the default for NEW strokes (this is the groundwork for a select-and-edit tool). A SELECT toggle on the bar (or the S key) makes this a tiny NON-DESTRUCTIVE vector editor: click a stroke to pick it (accent box), and the bar's controls retarget to that stroke — recolour it, change its dither, toggle bevel/boil, drag its thickness — while a property strip adds bevel-SIZE + boil-INTENSITY + outline-WIDTH sliders and bring-to-FRONT / send-to-BACK ordering. Edit any stroke any time; nothing is baked. A 7-colour pen — black/blue/red/green/cyan/magenta/yellow (cyan is a dark teal; pico32 has no true cyan) — picked from an always-visible palette strip (the seven swatches show their real colours; the active one wears an accent tab); each stroke keeps its colour. The fat brushes can be filled with a dpaint-style dither — a Bayer-ordered density ramp (~12→87% ink via fillp), likewise shown as an always-visible swatch strip — the step before a real flood-fill. A stroke can instead carry a GRADIENT FILL (the G-key popover): its body dithers from the pen colour to a second colour across the stroke, with an ANGLE and a SPREAD knob — a small spread keeps solid ends with a narrow blend band (aaaaa→bfy→zzzzz), spread 1 is an even ramp end-to-end (abc…xyz); it's the dpaint dithered-gradient scoped to a brushstroke (wired for the stamp brushes + the wet-paint body, whose drips run in the from-colour). Any stroke can also cast a DROP SHADOW — the whole silhouette re-rendered dark and offset AWAY from the sun, so it reads as floating above the paper; it's the SAME sun as the bevel, so spinning the sun swings every shadow and every bevel rim together (toggle it in the SUN popover). WIDTH is live on the MOUSE WHEEL: scroll to set the brush size, or scroll mid-stroke to taper/swell the line — it's captured per point, so the change stays where you made it (real pressure, not a uniform rescale). The whole toolbar is ink-on-paper: white buttons, black glyphs; the brush dropdown opens a 2-column icon+name grid. A flood-fill tool + the pixelsnap animated-icon export come next. Two-row top panel (ink-on-paper). ROW 1 (brush + effects): a brush dropdown that opens a 2-column icon+name grid (ink/pencil/liner/marker/chalk/sketch/spray/bristle/paint/nib/brushpen/reed/twist/oil), a thickness slider, a BVL toggle, a BOIL cycle (off/wobble/pulse), UNDO, an OUT(line) toggle + an outline-colour ring chip, and a SUN button (opens a light-dial + colour + spin popover + a DROP-SHADOW toggle). ROW 2 (colour + fill): the 7-colour palette, the dither-pattern strip, a GRADIENT button (a ramp glyph — opens the gradient popover: on/off + far colour + spread + angle; the G key does the same), and a SELECT (marquee) toggle. Active swatches/toggles wear an accent tab. Drag to draw; the MOUSE WHEEL sets the width live (scroll mid-stroke to taper/swell it — per-point pressure). Turn SELECT on (button or S key), click a stroke, then edit it via the bar + the bevel-size/boil-amt/outline-width/shadow-distance sliders and the FRONT/BACK ordering buttons. Keys: B bevel, O boil, S select, U undo, C clear, G gradient popover, [ / ] rotate the calligraphy nib angle, , / . rotate the bevel light (the sun), / cycles the sun's colour, \ auto-rotates the sun.

added 2026-06-30

touchpad

Pixel-art reference for the proposed on-screen touch controls (docs/design/touch-controls.md): a live parts demo, plus the three responsive placements - deck, rails, overlay - mocked in device frames. Design exploration, NOT wired into the engine yet. The sprites (touchpad.cart.js) are drawn with our own tools at native resolution and colorkey'd so they sit transparently on the game - a 4-way and 8-way d-pad, an analog stick, A/B buttons with idle/pressed states, fire buttons. Page through four views with SPACE or a click: (1) PARTS + a live demo you drive with arrows/Z/X; (2) DECK - portrait, game on top and controls in the band below (PICO-8 layout); (3) RAILS - landscape, game fills the height and controls ride the side rails; (4) OVERLAY - no spare space, controls hug the thumb corners on top (the fallback). The placement that wins is chosen by the available letterbox, per the design doc. SPACE / click = next view · (view 1) arrows = stick + d-pad, Z = A, X = B

added 2026-06-30

camrot

Camera-rotation test card. A little town — checker ground, colored buildings, round trees, and a red NORTH arrow planted in the world — under a camera that continuously rotates (and gently breathes its zoom). The whole world banks around the screen centre while the HUD stays upright. On the GPU it's a Camera2D matrix; on the software canvas (iOS/Switch) it's the offscreen-world-layer rotate-composite — this card is the quick on-device 'is camera rotation working?' check, no input needed.

added 2026-06-29

tinyjam — heart + notes logo

Internal asset cart: draws the Tinyjam logo — a glossy amber heart cradling a smooth cream beamed eighth-note pair, all from engine primitives (no bitmap-font glyphs); a one-line tweak swaps the note to berry-jam purple. Tweak the constants at the top and re-bake to generate variations.

added 2026-06-29

floorplan

One cart, many floorplans: a real Floorplanner project loaded at RUNTIME (not baked) and walked top-down. Fetch any project with data-tools/fmltools/floorplanner.js -pid=<id>, then run with --data/$DE_DATA or drag the .json onto the window. Same look as floorwalker/seinelaan. WASD/arrows move, T toggles sprites vs boxes.

added 2026-06-26

More Note Bass ⚡2×audio

A tiny groovebox that splits the difference between the drum-machine grid and One Note's bass feel. Two drum rows — KICK and SNARE — sit over FIVE bass rows locked to a minor-pentatonic scale, so every step can hold one in-scale bass note without needing a piano roll. The bass stays monophonic by column: light a note and that step becomes that pitch, simple and punchy like a baby 303 sequencer but with honest on/off cells. A starter groove is baked in so it thumps immediately. Tap or drag cells to paint; one octave of GarageBand-style musical-typing keys (A W S E D F T G Y H U J) transposes the bass root chromatically, Z/X shifts that root by octaves, `SUB` folds in an extra oscillator one octave down, and the arrow keys (or on-screen buttons) change tempo and swing.

added 2026-06-26

bunnymark

The classic sprite-throughput benchmark. Hold A (or the mouse / a finger) and bunnies pour out of the corner, bounce off a gravity floor and the walls, and never stop while a live counter climbs and the FPS readout holds at 60 — until the machine runs out of blit budget and the whole swarm slides into slow-motion. The number it sags at IS the benchmark, and a "60fps held @ N" line keeps the session's high score. Every bunny is one sspr() of a 32×32 sprite — a hand bunny posterised into the pico32 palette and tinted five ways via palette-index ramps (NOT pal()-recoloured: pal() flushes the GPU sprite batch per call and runs a per-pixel recolor on the software canvas, so baking the tint into the sheet keeps the loop a pure blit), making it a clean test of the sprite-blit path — exactly the workload the render-backend toggle swaps: open settings → rendering and flip between hardware (GPU immediate-mode) and software (CPU canvas) to watch the held-bunny count move between the two engines. Physics is a fixed per-frame step on purpose, so the slowdown shows as honest slow-motion instead of teleporting. HOLD A/mouse/touch to pour, B to reset.

drawall — every draw command

A reference cart that exercises EVERY studio.h drawing primitive in one frame — pixels, lines (thick/bezier), rects (incl. rotated + fillp dither), circles/ovals/arcs/rings, triangles/ngons/stars/polys, rounded rects, sprites (flipped/scaled/rotated, pal()-recoloured, colorkeyed), a tilemap, a textured triangle (tritex), text (outlined/rotated/scaled), camera/clip/zoom_rect — all spinning per frame. The one cart to throw the whole draw layer at (canvas-diff + build-all hit it), doubling as a visual catalogue of what the engine can draw.

grow balls platformer

A silly pogo-platformer. You're a little naked cartoon guy with visible balls — eat the fruit and veg scattered through the world and your balls GROW. Tiny balls only manage a small hop, but once they get big enough they turn into a spring: land and you POGO, and the bigger your balls, the higher you bounce. Steer in the air to land on the next platform (and the next snack), keep growing, and pogo a tower of one-way platforms all the way to the MOON. Arrows/WASD move, Z or Up to jump / super-bounce (tap on landing), hold Down to rest on a platform, R to restart.

roadview

Drive around REAL road data, loaded at RUNTIME. The network is neither generated nor baked into the cart — it is an OpenStreetMap export (fetched by data-tools/roadview/osm-roads.js, or the synthetic --demo set) read from a JSON file when the cart starts, so the SAME cart shows any town: swap the file, see a different city. This is the data-driven-cart experiment that kills the floorwalker/seinelaan smell of regenerating a cart per dataset (docs/design/external-data-carts.md). Roads are drawn as the FULL hierarchy — highway, arterial, secondary, tertiary, ordinary street, service, track, red bike path and dashed footpath — each its own colour at a width sized in real metres (so roads fatten as you zoom in). Nothing is dropped: the long tail of uncategorised OSM land (quarries, schools, stadiums, aeroways…) becomes a MUTED hashed dither understory, each category a stable colour+pattern from its tag. Canals are stroked, water areas filled in blue, parks and woods filled green, and building footprints + individual street trees revealed as LOD-gated detail once you zoom in close (B toggles footprints, T toggles trees) — all beneath the roads, with the bounding box auto-fitting to the screen. Opens on data/demo.json by default — then just DRAG any .json from the data folder onto the window to load that town, or click OPEN (top-right) to reveal the folder in Finder. Built on three tiny EXPERIMENTAL engine hooks: de_data_path() (--data <file> / $DE_DATA), de_dropped_file() (drag & drop) and de_open_path() (reveal folder); the JSON is parsed by runtime/json.h (vendored jsmn). Controls: arrows / WASD pan, left-drag grabs the map, mouse wheel zooms, 0 resets the view, B toggles building footprints, T toggles trees; drag a .json to load it, OPEN reveals the data folder.

rotstress — rotated-sprite stress test

A deliberate worst case for the software canvas rotated-sampling path: a storm of spinning sprites plus big rotated scaled blits and a textured quad, all opaque, so the per-pixel inverse-map + texel gather dominate. Built to be profiled — crank the sprite count with UP/DOWN to push past the frame budget and see where the time goes.

cityview

RENDER TEST: pseudo-3D top-down city (GTA1 meets Zelda) WITH drivable raised highways folded in (was the separate overpass experiment). Drive a seeded, brick/window/block/stucco-TEXTURED city. M cycles five building view modes: (1) NORTH-UP camera-locked, always the south fronts, zero diagonals; (2) HEADING-UP camera rotates to heading, you see the 1-2 walls you drive toward, every wall UP still screen-up (the keeper); (3) BILLBOARD flat cards (props not boxes); (4) LEAN-OUT roofs pushed off-centre (the melty contrast); (5) PERSPECTIVE a real pitched pinhole camera (perspective divide -> horizon, foreshortening, towering buildings) the parallel-oblique modes can't do, with live pitch/eye tuning (,. and ;'). F lays a FLYOVER over the city: off / straight overpass / s-curve / spiral on-ramp / two-level stack interchange. A flyover is a road whose nodes carry a z; because height extrudes straight up the screen it reads as an elevated deck (running surface + dashed centre line + fascia thickness + pillars + dithered ground shadow). Drive UP a ramp and the camera rises (camz) so the city sinks below; the car z snaps to the nearest REACHABLE deck so you board via ramps and drive UNDER high decks. T toggles wall textures. Proves the ADR-0021 projected-primitive vocabulary in one place: project() (world x,y,z -> screen), pdisc (a ground circle is an ELLIPSE once rotated -> projected N-gon: ponds, car shadow, future roundabout islands), pline/pdash (projected dashed line: the deck centre line), pproj_poly (project-then-polyfill: lots + deck shadows). Whole renderer is flat quadfill + tritex-textured walls. Arrows drive, M view, F flyover, T textures, [ ] zoom, R reseed. The cityscape-renderer bench for big-game seam #2.

added 2026-06-24

linecompare

LINECOMPARE - watch two rounding rules pick pixels for the SAME line, magnified so every cell is visible. A line on a grid has to choose which cells to light: DDA (blue) walks the long axis one step at a time and rounds the other coord, so it lights exactly one cell per column/row - crisp, but it rounds on its own terms; COVERAGE (orange) asks, for every cell, whether its CENTRE is within half a pixel of the line - the same rule fills/outlines use. Cells both rules agree on are WHITE; the blue and orange cells ARE the 'two rounding rules' the software-canvas notes describe. A third rasterizer, DDA PERPENDICULAR-OFFSET (parallel 1px DDA passes), is crisp AND uniform-width but gappy at diagonals. Thickness lays bare that DDA is intrinsically 1px (thickness is an add-on whose perpendicular width shrinks toward 45 degrees) while coverage gets thickness for free; coverage also has a three-way CAP toggle (round capsule grows the line longer as it thickens; butt cuts flush like DDA but can clip a thick diagonal's tip; square is the in-between - a fixed ~1px nub that always covers the endpoints but never balloons). Finding: at 45 degrees no thick-line method wins on all of crisp/uniform-width/gap-free. Controls: B cycle 5 views, UP/DOWN thickness, C coverage cap style, LEFT/RIGHT rotate, A auto-spin.

added 2026-06-24

skewlab

SKEWLAB - clean 1px road edges at any SKEW or CURVE; a petri dish for streetlab's skewed-junction kerb issues (missing outline, stray black pixels at the crossing, doubled edges) and the fix. Models a road as a UNION of capsule segments - two long crossing arms (skew) or many short chords along a fake-Perlin sine centreline (curve). Two draw methods: PER-PIECE casing (what streetlab does - each segment lays a 1px-proud kerb then asphalt, so at any overlap one piece's casing strands inside another's asphalt, giving interior strays + missing edges, worse with skew and far worse on a curve where every joint overlaps); and UNION 1px outline (the fix - fill the whole union once, then one coverage border = an asphalt pixel with a grass 4-neighbour, the same rule circ/poly already use). The union outline is generator-agnostic: it traces the boundary of whatever is filled, so straight, skew and curved/Perlin roads all render as one clean 1px kerb. Readouts: interior strays (0 for the union method) and sampled edge thickness (1px). Controls: Z method, C skew/curve, left/right angle or amplitude, up/down width, R reset.

added 2026-06-24

arcsym

ARC FLIP SYMMETRY — a petri dish for streetlab's ≤1px corner floor: why a mirrored arc has the SAME pixel count but a DIFFERENT staircase, and how to fix it. On streetlab's default 4-way intersection the four kerb fillets are mirror-symmetric in real space, yet the rendered kerb edges land ≤1px apart (the docs' accepted floor). The cause: streetlab snaps each arc vertex to the grid with ri() and THEN strokes/fills, so re-rasterising the mirror rounds TWICE — ri(mirror(v)) != mirror(ri(v)) at half-pixel alignments — and the edge drifts. The fix the docs predict: rasterise ONE corner, then BLIT its cells mirrored (a pure index reflection is exact by construction). The cart draws a quarter arc and its flip on a magnified EVEN-width grid (mirror axis on a pixel boundary, like x=160 on a 320 screen): blue = the original, green = flip matches the true mirror, RED/orange = where the naive flip is off a step. A live stat sweeps the sub-pixel phase and counts how many alignments the naive flip breaks at (some — that's why it's a subtle floor) vs the blit flip (zero, always). Controls: Z naive re-raster <-> blit cells (the fix); S stroke <-> fill; left/right sub-pixel phase; up/down radius; R reset. spec() proves the blit is pixel-exact at every phase/radius/shape.

boom

A destruction sandbox for a criminal city — a petri dish of six blast effects over an honest fire + material world. Two honest layers crossed by two causes: the ground is a grid of materials with FUEL + a fire level that spreads cell-to-cell by probability (navkit's fire model flattened to 2D — ignition resistance, wind bias, water chokes it, fuel burns to ash) and a PRESSURE layer with structural HP; everything airborne (fireball, sparks, shrapnel, ballistic debris, glass shards, smoke plume) is a particle that cools along a blackbody ramp. SIX detonation tools (1-6), each a recipe over the same systems: BLAST (the all-rounder), GRENADE (small, sharp, all shrapnel), MOLOTOV (no shockwave — a flame splash that paints fire), CAR BOMB (debris-heavy, throws chunks), GAS MAIN (a hiss, then a column of fire erupts upward), and RAM CAR (a kamikaze car screams in from off-screen at your click and crashes — car-bomb — into the first wall it meets). The world is a city block of concrete buildings with glass shopfronts, wood shacks, cars, and a barrel cluster by an oil slick: barrels and cars cook off into their own blasts (a yard of barrels chains, a torched car car-bombs itself); glass shatters and concrete walls collapse under blast PRESSURE, not heat — and a blast knocks wall cells loose as real PHYSICS BLOCKS that fly, tumble, slide to rest and settle back into rubble (a prototype of sloop's deferred per-tile demolition rung). Tools are picked by clicking a row of cute pixel-art buttons (no keyboard shortcuts): TAB toggles BOOM/BUILD; in BOOM click a blast then click/SPACE to detonate, wheel sets charge; in BUILD click a brush to paint materials (ground/road/grass/wood/oil/water/barrel/car/glass/concrete), drop a TORCH or a CRATE, pour a GASOLINE fuse, or place an EXPLOSIVE charge — lay a fuse to a charge and torch the end. A cursor label names the cell under the pointer. C clears fire & smoke, R resets. The sandbox seed for a roam-and-burn city game.

Cityplan — a world you can lift the roof off

The full merge of Lotfill + Interiors: the same fill-language at two scales, stacked so you read the whole world by ZOOMING. A WORLD selector reads terrain + an urbanization field and picks per region — WILD land gets scatter wilderness (woodland/meadow/beach/scree/wasteland + all the instance art), FARMLAND gets rows of crops + hedgerows, CITY gets blocks SUBDIVIDED into a street-fronting ring of VARIED lots (dense residential rows TERRACED into shared-wall runs, detached houses with a fenced/hedged yard + driveway). Zoom OUT and you see the world from above: terrain, woods, fields, and a city of ROOFS. Zoom IN and each city roof LIFTS to reveal that footprint's floor-plan (a recursive BSP room tree with emergent labels — living/kitchen/bath, shop/back/office, bay/storage fall out of area/frontage/adjacency rules, never a type list — doors through every wall, windows on the outside). Zoom IN further and the FURNITURE appears. A decay field ruins derelict DISTRICTS (collapse punches the roof/massing open, overgrow creeps it green). Commercial/industrial block interiors are paved (asphalt/plaza/gravel + parking), and ~1 in 5 courtyards gets a fountain/statue/well/obelisk centrepiece. The reveal is pure LEVEL-OF-DETAIL: a roof lifts only once its building is big enough on screen to read (no mush of beds), and the floor-plan is generated LAZILY (far buildings cost a roof rect). F force-lifts every roof (dollhouse); O cycles a field overlay (world-kind/cover/density); G the block+lot grid. Inherits both parents' seams: pure fn of a hash-seed, draw == query (room_at/world_kind_at run as a collision/interaction query). WASD/ZX move, R new seed.

gridcity

EXPERIMENT (v1, bare): the AGGREGATE TILE-DATA SIMULATION behind SimCity 2000 — not road geometry (roadlab/streetlab) and not a top-down generator (procplaces), but the consequence side: paint terrain, tile roads, and R/C/I zones, and the engine COMPUTES the emergent data layers from them and from each other every sim tick. v1 proves the core feedback loop crime↑ → land value↓ → crime↑ (the slum spiral), broken only by POLICE coverage. It is all two spreading primitives over a 64x48 grid: a DIFFUSION blur (4-neighbour average, mass-conserving) for population density + near-water land-value, and a DECAYING SPREAD (strongest-neighbour minus a per-step decay = a distance falloff) for service coverage — because an averaging blur thins a single police station to nothing and never suppresses crime (the one non-obvious v1 finding). Cross-layer formulas wire them: land value = centre-proximity + near-water − crime; crime = base + density − land value − police. Opens on a seeded sample city with one unpoliced slum. Pick the brush from a cute icon toolbar under the grid (or the keys), and click an overlay name to switch the data view. Number keys 1-5 toggle overlays (City / Land value / Crime / Police / Density); LEFT-drag paints the current brush, RIGHT-drag erases; R/C/I zone, O road, W water, P police station, E erase; SPACE reseeds. Carries a spec() that pins the loop: an unpoliced dense block reaches crime 87 / land value 44, and dropping a station collapses crime to 0 and rebounds land value to 87. Design + roadmap (v1 bare → v1.5 pollution + the develop/abandon growth valve driven by an RCI demand meter → v2 full: densities, power, water, traffic, fire/education/health coverage) in docs/design/data-layers.md.

4b. the mouse

Read the pointer — the keyboard's sibling. mouse_x()/mouse_y() track the cursor, mouse_pressed() is a click, mouse_down() is a drag, mouse_wheel() zooms toward the cursor, and the three buttons MOUSE_LEFT/RIGHT/MIDDLE. LEFT-drag the box, wheel to zoom it toward the cursor, LEFT-click empty space drops a dot, RIGHT-click clears, MIDDLE-click resets.

beltworks tycoon

A factory-builder in miniature, after Factorio. Three raw ores sit in the ground — ORE, COAL, CRYSTAL — and five machines refine them up a tree you plumb together with belts: a SMELTER turns ore+coal into PLATES, an ASSEMBLER presses 2 plates into a GEAR, a CHARGER turns crystal+coal into a CELL, and a FABRICATOR combines a gear+cell into an ENGINE. Belts carry one item per cell and BACK UP when blocked, so throughput is all about the layout — and coal feeds two machines, so you end up splitting that line. Miners only work placed ON a deposit. Deliver engines to the HUB to hit the quota (25), then keep optimizing. Opens with a complete demo factory already running. Real-time — you build while it runs. Mouse: pick a tool, left-click/drag to lay belts and place machines, right-click erases, R rotates; SPACE pause, [ ] speed.

Dub Siren ⚡2×audio

A dub siren, after King Tubby / Scientist and a sound-system mixing desk — not a melodic instrument but a GESTURE box you play OVER a riddim. Two detuned oscillators warble (an LFO bends their pitch — the 'wheeeoo' siren) and fire into a huge FEEDBACK DELAY: stab the siren, lift your hand, and the echo THROWS the stab tumbling into the distance; push the throw past the red and the delay self-oscillates and HOWLS until you pull it back. A big reverb splash sits under it all. The FIRE PAD is the instrument — hold to sound it (or SPACE / LATCH), Y = pitch, X = throw (feedback). WOBBLE rate + DEPTH set the warble; ECHO time (sweep it while it rings and the repeats pitch-bend — the dub classic); VERB the splash. 1-4 pick the siren shape (whoop / two-tone / ramp / zigzag); ↑/↓ pitch, ←/→ throw, L latch. Built on echo() feedback + note_lfo(LFO_PITCH) + reverb() — the hands-on twin of the dub auto-radio.

Dubdesk ⚡2×audio

A generative dub groovebox — the jam station that fuses three liveset chassis into one instrument over a single clock. RHYTHM: 3 euclid drum rings (KICK/SNARE/HAT) plus a 4th MELODY ring; dial each ring's density/rotation and it plays itself. The melody ring fires the LPG VOICE at a pitch read from a little shift register (a coherent, slowly-drifting motif; M re-rolls it). VOICE: the LPG (west-coast low-pass gate) — the melody ring auto-plays it AND you can finger it live on A S D F G H J K; DECAY/FOLD/COUPLE sculpt the plonk. SIREN: your live hands — the FIRE PAD (hold / SPACE / LATCH), Y = pitch, X = THROW, which rides a MASTER echo so a throw smears the WHOLE groove into the distance (the dub move); past the red it self-oscillates and howls. The PART tabs (RHYTHM / VOICE / SIREN) re-target one shared 3-knob row; in RHYTHM, 1-4 (or tap a ring) picks which ring the knobs edit. Z/X/C switch part. Per-part MUTE on Q/W/E (or re-tap a PART tab) drops the DRUMS / MELODY / SIREN — a muted melody still lets A-K play through, a muted siren still lets the pad throw the mix. When the MELODY ring is selected its 3rd knob becomes MORPH (lock the riff or let the shift register evolve); ↑/↓ set SWING. Everything stays visible and sounding at once. Built from euclid + lpg + dubsiren; spec in docs/design/dubdesk-spec.md.

Easel ⚡2×audio

A complete west-coast synthesis voice, after the Buchla Music Easel (1973) — where the `lpg` cart showed the low-pass gate alone, this is the whole instrument it belongs to. The chain makes brightness ADDITIVELY (the opposite of every subtractive cart): a COMPLEX OSCILLATOR (INSTR_FM — RATIO sets carrier:mod, TIMBRE the cross-mod depth from sine to clang, both live) → a WAVEFOLDER (FOLD, glassy/metallic harmonics) → a LOW-PASS GATE that closes volume AND brightness together (the highs die first — the organic plonk). A FUNCTION GENERATOR (RISE/FALL slope) shapes it: PLUCK fires it on each tap (a bonk), PRESS rides the gate from finger pressure, and CYCLE free-runs it as an LFO routed to the GATE (tremolo) or TIMBRE (auto cross-mod sweep). Played on a pressure RIBBON — x = pitch (SNAP to a pentatonic scale, or FREE/microtonal like the real Easel's capacitive keys), y = pressure (harder = louder + brighter + more folded); A-K play it from the keyboard too. It is POLYPHONIC (4 voices) — chords on A-K, overlapping plucks, and sequence notes ring over each other. RUN starts a PULSER that plays it itself: with SEQ it steps a 5-NOTE SEQUENCER (tap a step cell to set its pitch), or RND fires random scale pitches. Drag the ribbon; knobs RATIO/TIMBRE/FOLD/RISE/FALL/RATE; buttons pick PLUCK/PRESS, CYCLE off/gate/timbre, RUN, SNAP/FREE, SEQ/RND (Z/X/C/V/SPACE keys mirror them). Spec: docs/design/easel-spec.md.

eno radio ⚡2×audio

A beatless ambient station after Brian Eno's Music for Airports (1978). Each voice is a LOOP of its own length in seconds, the lengths mutually coprime, so they drift in and out of phase and never line up the same way twice - and there is NO chord progression: each loop just holds one note of a rolled pitch-set, so the harmony is whatever loops happen to coincide (emergent, not authored). The window shows it: one lane per loop, a playhead creeping at the loop's own speed, a bloom where two playheads meet - you watch the chord form. Not-samey by design: the album is four SETUPS and the seed rolls one per song - 1/1 piano (real INSTR_PIANO struck), 2/1 voices (sustained INSTR_VOICE choir), 1/2 duet, 2/2 synth drone - plus key + mode (lush, never dark), register, a fresh coprime period set, per-voice detune (ombak), and timbre macros; each loop also waxes/wanes over ~90s. SPACE/tune next, R same seed, [ ] history, drift/tone/density knobs, B picks the movement, M power, H help. Pin a favourite via ENO_SEED. First radio station to use real INSTR_PIANO and a sustained INSTR_VOICE choir, and the first with no chord brain at all.

Euclid ⚡2×audio

A Euclidean rhythm box, after Mutable Instruments Grids / the Euclidean sequencer — the whole magic is ONE idea: spread k hits as EVENLY as possible across n steps and you get tresillo, the clave, the world's drum patterns, for free, just from numbers. So there's no step grid to draw by hand; you DIAL each drum's DENSITY and ROTATION and the groove blooms and dissolves generatively. Five nested rings — KICK, SNARE, HAT, OPEN HAT, PERC — each with its own step count, so the rings drift against each other (polymeter) and the loop never sits still; a playhead sweeps each ring. Pick a track with 1-5 (or tap the strip on the right); ↑/↓ sets its density (hits), ←/→ its rotation, or drag the HITS / STEPS / ROT knobs. M mutes the selected track; SPACE = MUTATE, a one-tap shuffle that nudges every density to morph the whole groove. TEMPO rides it. Built on the engine's euclid() Bjorklund helper — the rhythm companion to kaoss and onenote; the loop it makes is exactly what kaoss is built to mangle.

facegen

The NPC-portrait SYSTEM for the GTA-style world (sits beside streetlab, sloop, flank, worldgen, lotfill, interiors): roll a person off the corner and they fill the screen and say their piece in a comic conversation box. Seventeen ARCHETYPES — made men, gangsters, corner boys, dealers, pimps, working girls, fiends, civilians, beggars, working-class laborers (hard hat), drunks (flushed), senior citizens (bespectacled, wrinkled), ballers (headband), businessmen (suit), baristas, historians and teenagers — every face built ONLY from primitives (ovalfill/trifill/line, no sprite art) and every one different, drawn in a Hotline-Miami-inspired inked style — heavy black outlines, hard planar light/shadow shading under a GTA-style warm upper-left key, sunken intense eyes with glowing irises, a protruding outlined nose and gritted-teeth grimaces — with subtle per-face ASYMMETRY (jaw, eyes, brows, nose nudged off-centre so no face is mirror-perfect). There is no portrait 'engine': a person is just a bag of GENES rolled by rnd() — skin tone (a six-step pale-to-very-dark ramp, each a 3-tone highlight/base/shadow), face shape (round / long / square / heavy / slim / gaunt), nose (button / straight / wide / Roman / pointy), hair (high-top fade, cornrows, afro, slicked-back, durag, bun, bob...), facial hair (stubble/'stache/goatee/full beard), a 'wrinkly' trait (forehead furrows, crow's feet, nasolabial folds on weathered/older faces), and a bitmask of 1990s accessories: gold rope chains, black shades, hoop & stud earrings, bandanas, durags, snapbacks, fur hats, lit cigarettes with rising smoke, gold teeth and grills, cheek scars, sweat beads, beauty marks, and FACE TATTOOS that are real TYPOGRAPHY — rotated gang lettering ('MONEY'/'RIP'/'213') in the bitmap fonts, CP437 symbol glyphs (♠♣♥♦☼♫ arrows), and tiny ascii-art motifs, with an 'excessive' fully-inked variant. Each ROLE biases the roll so a mobster reads mobster (slicked hair, suit + tie, cigar) and a corner boy reads corner boy (hoodie, cap, wary eyes); women get a 'babe' trait some of the time — slim soft face, big doe eyes with mascara lashes, thin arched brows, fuller glossed lips, rosy cheeks and a Monroe mole — but NOT all do, the rest are plainer or older/greying. A role-appropriate procedural NAME ('Frankie "Big Tony" Moretti', 'Lil' D-Loc', 'Bambi') and a fitting BARK are drawn with a typewriter + per-letter tick, the mouth flapping while it talks, blinks, an idle hard-stare squint, an idle head-bob, a framed 100px mini-avatar of the same face, and a role-tinted mood backdrop (warm restaurant / night street / pink neon / grim alley). The whole Npc struct + roll_npc() + draw_portrait() lift straight into the game. SPACE/click = new person, Z = same person another line, 1-8 = force a role, X = tick on/off.

Grenadier ⚡2×audio

A triple voltage-controlled FILTERBANK drone/acid synth, after the Grendel RA-99 Grenadier (Rare Waves, 2020) — a CMOS semi-modular box whose whole voice is THREE parallel resonant filters swept together in a 2D space (the TB-303 filter is its tonal cousin). Ported entirely cart-side (no new engine DSP): three held voices on one root, each through its own resonant filter, summed. The XY PAD is the instrument — ALPHA (x) sweeps all three filters ±2 octaves, BETA (y) opens the SPACING from a tight cluster to a wide spread; a live frequency-response strip shows the three peaks move. LAYOUT switches RA-99 (lowpass + 2 bandpass) vs RA-9 (three bandpass). The in-scale KEYBED (A S D F G H J K L) sets the drone ROOT and glides to it. SPACE / Q / MORPH (a trapezoid VCO morphing triangle→square) / RND (per-trigger CMOS drift). GATE pulses the drone in time for the techno chug. Drag the SWEEP pad; ASDFGHJKL = root; ↑/↓ gate rate; ← / → tempo.

Kaoss ⚡2×audio

An XY effects pad, after the Korg Kaoss Pad / Kaossilator — a driving techno loop plays itself so both hands are free to MANGLE the whole mix with your finger on a big XY pad. Pick a PROGRAM (1-4) and the X/Y axes drive that effect's two parameters; touch the pad to engage, lift to bypass, or HOLD to latch a mangle. Only the engine's ride-safe effects are on the pad (filter / varispeed / echo / tremolo — the ones built to sweep live), so it never stutters. FILTER: x = lowpass < open > highpass, y = resonance (the DJ filter). ECHO: x = delay time, y = feedback (the dub throw). GATE: x = chop rate, y = depth (square-tremolo stutter). TAPE: x = speed, tape-stop < > spin-up (varispeed dive). The performance masher that onenote and grenadier plug into. Drag the pad (mouse/finger); 1-4 pick program; SPACE = HOLD; left/right = tempo.

lofi fm ⚡2×audio

Lo-fi jazzy hip-hop - the Nujabes / J Dilla / beats-to-study-to pole, dreamier and hazier than lowend's hard boom-bap (we ship that too). Lush extended Rhodes jazz (maj9/m11/13 loops) over a dusty SWUNG kit, wrapped in vinyl crackle + tape warmth. The headline brain is THE DRUNK POCKET - the off-grid feel: the snare drags LATE, the kick is lazy, the hats swing, with a little seeded humanize wobble - and it is ADJUSTABLE: a POCKET knob (LEFT/RIGHT) from tight (on the grid) -> loose -> behind -> drunk, defaulting to a tasteful moderate drag (never seasick unless you crank it); the loose feel lowend undersold, here done right and under the player's control. The harmony is a slow static 2-4 chord extended-jazz loop; a muted-horn / vibe sampled-feel dab floats over it, filtered + reverbed and laid back. The lo-fi rack (set-and-hold, per mood) is tape wow/flutter + gentle echo + reverb + a held vinyl-crackle bed (reused from vapor). The seed rolls a MOOD: sleepy / dusty / rainy / sunny (each sets tempo, scale, the default pocket and the crackle). The window is a cozy night room: a rainy window, a breathing desk lamp, and a turntable whose platter spins with the tempo. SPACE next, R replay, [ ] history, LEFT/RIGHT pocket (tight..drunk), UP/DOWN tempo, T tone, B band (keys rhodes/wurli, bass upright/round, dab horn/vibe/off), M power, H help. Pin via LOFI_SEED.

logic

A redstone-lite logic sandbox. Place switches, wires and gates on a grid and watch signal flow tick by tick. Build a blinker from a NOT gate wired into itself, an SR latch from two NORs, a half-adder from XOR + AND; clocks, repeaters and pulse-stretchers handle timing. Opens with four live demo circuits already running. The digital signal layer ported from navkit's mechanisms experiment — first of a planned family (pipes, belts, gears). Mouse: click a palette tool, left-click the grid to place, right-click to erase; pick the HAND to flip switches / hold buttons / cycle a clock's period. Keyboard: arrows move the cursor, Z place, X erase, C use, R rotates a gate's facing, number/letter keys pick tools, SPACE runs/pauses, . single-steps, [ ] change speed.

LPG ⚡2×audio

A low-pass gate — the signature voice of west-coast / Buchla synthesis. When a real struck thing decays it gets quieter AND duller at once (the highs die before the fundamental); a low-pass gate models that by closing a VCA and a lowpass filter together from one springy vactrol envelope. So this isn't a filter you sweep — it's the gate that turns a steady tone into an organic 'bonk'. Eight tuned marimba bars are each a held tone, silent until struck; a strike fires a vactrol envelope that drives note_vol AND note_cutoff AND the wavefolder in lockstep. FOLD adds harmonics (sine→metallic) for the gate to chew on; DECAY is short woody plonk → long ringing marimba; COUPLE is the headline A/B — 0 = a plain VCA (the tone stays bright as it fades), 1 = the full low-pass gate (brightness dies with the volume, the organic plonk). Each bar glows white→yellow→orange→wood as its gate closes, so you SEE the timbre decay. Play it like a marimba: A S D F G H J K, or tap the bars. Built on a pool of held note_on voices + coupled note_vol/note_cutoff/note_drive — the one liveset plaything with a genuinely new timbre.

plaid fm ⚡2×audio

Plaid's warm, melodic IDM, generated forever - the GENTLE pole of Warp, the anti-braindance/squarepusher: intricate but tender, never aggressive. The brains, cart-side over radio.h's clock: INTERLOCKING ARPEGGIOS (the headline) - 3-4 little bell/mallet/pluck cells, each cycling at its OWN length (5/7/8/9/11 steps) against the bar, so they phase and weave and the melody EMERGES from the overlap (the melodic cousin of gamelan's kotekan + eno's coprime loops, but pitched arps over harmony; all in one lush mode so every overlap is consonant). ODD METERS THAT FLOW - the bar is a rolled odd length (5/8, 7/8, 5/4...) and the soft broken-beat kit smooths it so it lilts rather than limps. MODAL DRIFT - a slow root walk under the weave (pad chord + bass) gently re-colours the fixed arps, the Plaid re-harmonisation, bittersweet maj7/9. FORM = ACCRETION - arps enter and recede on an arc, the weave thickening to a peak mid-track and thinning out, with a breakdown. The window WEAVES A PLAID: each arp is a coloured thread (its cycle length sets the stripe spacing), warp crossing weft, brightening where they overlap and when the arp sounds - the interlocking-arp brain drawn as the emerging tartan (the name). SPACE next track, R replay, [ ] history, LEFT/RIGHT weave density (sparse/warm/woven/full), UP/DOWN tempo, T tone, B band (arps bells/softer, kit broken/brushed), M power, H help. Pin via PLAID_SEED.

plantasia radio ⚡2×audio

Warm earth music for plants, after Mort Garson's Mother Earth's Plantasia (1976): bright, bouncy, whimsical little Moog SONGS, each for a different houseplant. The family's first MELODY-FORWARD station - the lead is the protagonist, not buried in the mix. Two new things: THE SONGWRITER (melody brain #3), a SEEDED theme-and-variation generator - a singable hook invented from the seed (the SAME every replay, unlike a solo) and developed across an A-A'-B-A songform with a final key-lift, sung by the mono Moog lead with portamento glide + vibrato (a held voice driven per-frame so it can slide); and the TRACK FEELS - the seed rolls one of five named feels (sprightly / swing / waltz / rubato / green), each bundling tempo, meter, groove, kit and density. The band is the dream-synth (moog) signal path four ways: gliding lead, springy filter-pluck bass, burbling sequencer arp, warm pad bed, celesta sparkle, a light synth kit. The window GROWS A HOUSEPLANT as the song plays - sprout, leaves unfurling, a flower opening on the outro; species seed-rolled, the seed on a nursery price-tag. SPACE next, R same seed, [ ] history, LEFT/RIGHT density, UP/DOWN tempo, T tone, M power, B band, H help. Pin via PLANTASIA_SEED.

runecrawl puzzle

A logic-puzzle roguelike where the dungeon and the machine share a turn. Each floor is a procedurally-generated chain of vaults, every door a portcullis wired to a RUNE-GATE you must satisfy to pass — AND needs both its levers, OR either, XOR exactly one, a NOT-trap starts thrown (turn it OFF), a CLOCK-rune blinks the door open so you dash through before it shuts, and a PRESSURE PLATE holds the door while you stand on it (it lingers a few steps so you can run for the gap — or lure a wraith onto it to hold it for you). Wraiths prowl the deeper vaults — bump one to cut it down, but let it reach you and it bites (you have 3 hearts). Explore by torchlight (raycast fog-of-war), satisfy each gate and take the stairs DOWN to a deeper, tougher floor — there is no top, only how far you descend (best depth is saved); death sends you back to the surface. The signal sim from the `logic` cart made diegetic — one circuit tick per step. Arrows/WASD move (into a lever to throw it, into a wraith to strike), Z/. wait, R descend anew.

squarepusher fm ⚡2×audio

Tom Jenkinson's bass-virtuoso drill'n'bass, generated forever - the sibling of braindance fm but a different beast: here the BASS is the protagonist. A fretless/slap fusion bass tears melodic lines over MOVING jazz-fusion changes (ii-V-I with secondary dominants + the tritone sub, cadence-pinned per section) while hyper-edited breaks shred underneath - and the track LURCHES between manic drill chaos and tender fusion-ballad (the Tommib calm). The brains, cart-side over radio.h's clock: THE BASS AS LEAD - a Hosono-style counterpoint walker (from ymo) cranked to virtuoso density (fast chord-tone runs with directional inertia, chromatic approaches, octave pops, and a SLAP transient - a noise pop on the accents); in SOLO sections the improviser (improv.h) takes over and shreds over the changes. RATCHETS + a VOLATILITY drum grammar (braindance's rhythm brains, pushed hotter). THE LURCH form - a rolled sequence of MODE blocks (tender / fusion / solo / manic) that detonate into each other; the form is the balance (ballad-burst vs workout vs lurch). Fusion Rhodes comps the changes, a lush string pad carries the tender interludes, a 303 squelches in the manic sections. The window is an oscilloscope the bass drives behind a Squarepusher-style LED mask (eye-slits that flash on the drums), with B (bass) and D (drum) level bars. SPACE next track, R replay (the bass plays it anew), [ ] history, LEFT/RIGHT density (calm/warm/hot/mental), UP/DOWN tempo, T tone, B band (bass fretless/fuzz, kit amen/808, keys rhodes/wurli), M power, H help. Pin via SP_SEED.

streetlab

The FOUNDATION sandbox for the AT-GRADE world, one tier BELOW roadlab. roadlab draws the grade-separated INTERCHANGE family (loop/flyover ramps that ELIMINATE the crossing); streetlab draws the streets that cross AT GRADE — a different geometry grammar (curb returns, small radii, turn lanes) flagged as unmodeled in docs/design/road-hierarchy-notes.md. The seam between the tiers is access control: freeway = ramp-only = roadlab, everything below = at grade = streetlab. M1: CURB-RETURN corner fillets — the headline at-grade primitive, an arc tangent to both curb lines whose radius is kept SMALL (it slows turns and shortens the pedestrian crossing, the opposite goal of a high-speed ramp). M2: SKEW + the T family via a leg model (a junction is a list of arms at bearings, nothing hardcoded to 90); the curb-return grammar is angle-agnostic so it re-solves for free, and a T drops the north arm to 3 legs / 2 corners. M3: TURN LANES + channelizing islands — a left-turn lane marked INSIDE the carriageway: a raised MEDIAN splitter on the centreline (the channelizing island) + the inner inbound lane delineated turn-only + a left-turn arrow; no outer widening, so it composes with skew. M4: the street WEB — a second VIEW (press v) generating a seed-driven GRAPH of intersections (nodes) + street segments (edges); gen_network() is a pure fn of (pattern, seed) with grid / organic / radial / cul-de-sac / SUPERBLOCK patterns + a curvature knob, and live SNDi metrics — mean degree, dead-ends, sinuosity, the degree-1/3/4 NODE MIX (the discriminator mean degree alone hides), and CIRCUITY (network path / straight-line, Floyd-Warshall). Stage 2: the SUPERBLOCK (fused-grid) is a continuous arterial grid wrapping a vehicle-discontinuous interior (cul-de-sac stems off the perimeter) — the one pattern with no algorithm in the planning literature; circuity proves it distinct, ordering grid 1.21 < superblock 1.59 < cul-de-sac 2.18 where degree/node-mix cannot tell the superblock from a cul-de-sac (the 'node degree alone is not enough' thesis). The curve knob winds only the interior local streets — the arterial frame stays straight. M5: the PEDESTRIAN layer (press k) — SIDEWALKS (the footprint inflated by SW, wrapping the corners) + ZEBRA CROSSWALKS at each mouth, stop bar set back behind them. M6: the MINI-ROUNDABOUT (press r) — the at-grade counterpart of roadlab's grade-separated ring: a circulatory disc with a MINI, TRAVERSABLE (mountable/domed) central island, flush teardrop SPLITTER islands, GIVE-WAY (yield) entries + counterclockwise circulating arrows; leg-model based, so it composes with skew/T/lanes/sidewalks. M7: the typed CROSS-SECTION (OpenDRIVE lane types) — a lane-section from the centre out, [median] driving×N [bike] [parking], toggled per element (m/b/;); the median is the same island primitive run continuously, and because the half-width HW = the SUM of the lanes present and every junction primitive keys off HW, widening the section re-solves the whole junction (curb returns, mouth, roundabout, sidewalks) for free. curb_return() + count_corners() + arm_face() + the network graph + round_icr() + cross_hw() + mean_circuity() are pure fns pinned by the cart's spec() (the first cart with one; 104 assertions). Controls: v switches junction↔network; junction: [ / ] curb radius (island radius in roundabout mode), - / = lanes, , / . skew, t = T, p = turn lanes, r = roundabout, k = sidewalks+crosswalks, m = median, b = bike lane, ; = parking; network: [ / ] seed, b = pattern, c = curve. Next: the modal active-travel layer (paths-as-edges, the superblock's permeable cut-throughs), then the §8.4 two-tier world. See docs/design/road-hierarchy-notes.md and docs/design/road-program-state.md.

the xx fm ⚡2×audio

The xx (Romy, Oliver, Jamie xx) station - an ARTIST station, the dark/intimate twin of wba. The whole identity is INTIMACY + NEGATIVE SPACE: the gaps ARE the song, dark-minor, nocturnal, everything drenched in a big reverb. THE NEW BRAIN is the BOY/GIRL CALL-AND-RESPONSE - two INSTR_VOICE singers, a low male (Oliver) and a higher female (Romy), TRADE sung phrases (one states, the other answers) and meet in unison on the chorus; who-sings-when, and the silence between turns, IS the structure. Each phrase is a moving melodic CONTOUR sung in short, articulated, breathing notes. Plus SPACE AS STRUCTURE - density stays low by design. Built on the stolen-playbook chord brain: five archetypes - CRYSTALISED (the guitar+bass interlock, voices trading), ISLANDS (a gentle UK-garage click), VCR (steel-pan sweet, Coexist), ANGELS (Romy near-solo, almost beatless), ON HOLD (brighter, a steel-pan hook). The band: the two voices, Romy's icy single-note reverbed guitar, Oliver's deep dub SUB bass, Jamie's pointillistic clicky kit + steel-pan/marimba dabs. The window is the stark white X with two glows - Oliver left, Romy right - brightening as each sings, fading on the reverb tail. SPACE next song, R same tune, [ ] history, LEFT/RIGHT space, UP/DOWN tempo, T tone, B band (voices duet/romy/oliver, perc kit/bare, guitar icy/warm), M power, H help. Pin via XX_SEED.

Turing ⚡2×audio

A generative sequencer, after the Music Thing Modular Turing Machine — the whole instrument is ONE looping SHIFT REGISTER and ONE big CHAOS knob. Each clock the register rotates and the recirculated bit is flipped with some probability: knob full RIGHT = 0% flip = the loop is LOCKED and repeats forever; knob CENTRE = 50% = pure RANDOM, a new pattern every bar; knob full LEFT = 100% = FLIP-LOCK, a locked loop of double the length. Park it just shy of locked and the riff slowly mutates — you sculpt a sequence by hand. The register's value is read out as a scale-locked PITCH (so it never sours) and two of its bits trigger a KICK and a HAT, so melody AND groove are the same evolving pattern. The 16 LEDs are the live register — TAP a cell to flip that bit by hand; a SEQUENCE strip graphs the recent notes so you watch the loop lock or drift. The CHAOS knob (or ← / →) rides lock↔random↔flip; LENGTH (↑ / ↓) sets loop length, RANGE the pitch span, TEMPO the clock; 1-4 pick the scale (min/maj pentatonic, dorian, aeolian); SPACE = SCRAMBLE a fresh pattern. A liveset plaything built on a cart-side shift register + an INSTR_SAW Berlin-school voice.

vapor fm ⚡2×audio

Vaporwave - the first EFFECTS-FORWARD station, where THE PROCESSING IS THE GENRE. Vaporwave is 80s/90s lounge / mall-muzak SLOWED DOWN and drowned in reverb + chorus + tape warble + echo, looped hypnotically. With no sampler we GENERATE the lounge source - lush Rhodes + pad + a sax/bell dab + smooth bass over a short, static extended-jazz loop (maj9/m9/9) - and run the whole mix through that chain; the drench and the slow wobble ARE the band. THE DRENCH is a SET-AND-HOLD vaporwave FX chain (big reverb + chorus + heavy tape wow/flutter + echo + a touch of bitcrush), configured once per song/mode. THE SLOW WOBBLE is varispeed ridden LIVE (sweep-safe): a gentle drift so the whole mix wavers like a tape running slow / a dying battery - the slowed/screwed sag, made visible as the scene wobbles. A held vinyl-crackle bed under it all. The seed rolls a SUB-STYLE: classic (Floral-Shoppe lounge + a slow gated beat), mallsoft (beatless dead-mall, max reverb), utopian (brighter eco pads), future funk (a touch faster + funkier). The window is the iconic scene: a sunset gradient, the striped vaporwave sun, a wireframe grid floor receding to the horizon. SPACE next, R replay, [ ] history, LEFT/RIGHT haze (dry..drowned), UP/DOWN tempo, T tone, B band (keys rhodes/wurli, lead sax/soft, beat as-rolled/beatless), M power, H help. Pin via VAPOR_SEED.

wba fm ⚡2×audio

The Whitest Boy Alive station - Erlend Oye's band (Dreams / Rules), an ARTIST station: the dial plays recognizably DIFFERENT songs OF THEIRS, not one texture re-keyed. The whole identity is RESTRAINT and SPACE - every instrument is dry and has room, nothing crowds; machine-tight precision meets live-band warmth. Built on the stolen-playbook chord brain: FIVE SONG ARCHETYPES, each a cited WBA track that fixes its groove, tempo, lead and form. BURNING (aeolian four-on-floor disco, driving, clean guitar chops + a pumping bass); GOLDEN CAGE (a dorian melancholic mid-pulse where the BASS carries the hook); 1517 (bright major pop, bouncy, guitar/bass interplay); COURAGE (gentle major maj7, slower, Rhodes-forward, lots of air); DONE WITH YOU (a funky dorian vamp, choppy palm-mute guitar + syncopated bass). THE TEXTURE is the negative-space DUET: the clean guitar's palm-muted chops and the melodic co-lead bass interlock with GAPS, over a tight clean kit, with warm Rhodes + a soft vocal on top. The guitar is a clean INSTR_GUITAR (steel string) through the CLEAN amp/cab voicing (ampcab.h: soft-clip, scooped-bright, light power-amp sag) + a slapback echo + a small warm room + a whisper of chorus - NO distortion, the restraint is the sound; the whole band is glued with gentle tape + bus compression. The window is a bare Scandinavian stage: four instrument blocks (guitar/bass/drums/keys) lit only when each plays, in lots of black space. SPACE next song, R same tune, [ ] history, LEFT/RIGHT feel (bare/room/warm/full), UP/DOWN tempo, T tone, B band (amp clean/chime/crunch, keys rhodes/wurli, kit tight/brushed), M power, H help. Pin via WBA_SEED.

One Note ⚡2×audio

A one-note funk groovebox — make a whole track move on a SINGLE note (after BeatCraft Studio's 'the magic of one note'). No melody, no piano roll: the funk is all RHYTHM, SWING, and sliding that one note around. A 16-step grid with three rows — KICK, SNARE, BASS — where the bass plays a single pitch on whatever steps you light. You transpose the whole loop by playing a new root on the little in-scale KEYBED (A S D F G H J K L, scale-locked to minor pentatonic so every root grooves), exactly like setting the root on a Keystep — and it's QUEUED: the new root latches in on the NEXT bass step, in time, with the armed key highlighted and a green tab marking the root that's actually sounding. SUB folds in the same note an octave down (the 'lower wave'). An XY PAD shapes the bass tone only — drag right for a brighter cutoff, up for more resonance (a Moog ladder filter, the funk quack). SWING drags the off-beat 16ths; TEMPO sets the head-nod. Tap or drag the grid to build a beat; type ASDFGHJKL to walk the root; ← / → tempo, ↑ / ↓ swing.

added 2026-06-21

clampstress

A deterministic torture test for the PER-CALL clamp cost shared by every software fill. Each circfill/ovalfill/polyfill/trifill calls poly_clamp_scan, which does 4 GetScreenToWorld2D (camera-matrix inverses) to find the on-screen scan box — but that box is constant for the whole frame unless the camera moves. This cart issues ~1500 TINY fills/frame (377 each of all four primitives, near-zero fill AREA), so the per-CALL clamp dominates — the rig to measure the ceiling of a per-frame clamp-box cache. Scene 0 STATIC (key 1, no camera: box identical every call). Scene 1 PAN (key 2: camera() pans each frame, so the cache must recompute once/frame and stay correct). Pure function of the frame counter — byte-reproducible. Baseline (per-call clamp, current): STATIC 1.90ms avg / 3.36ms max. Not a game; a profiling + regression rig.

discstress

A deterministic torture test for the SOFTWARE disc/ellipse fills (circfill -> disc_inside -> plot_pat, ovalfill -> ellipse_inside -> plot_pat) — the circfill/ovalfill sibling of polystress. Scene 0 SOLID (key 1, the span-fill optimization target): three big pulsing circles (large fill AREA), a 60-cell grid of small circles (fill COUNT + per-call bbox setup), wide/tall/round ovals (ellipse_inside across aspect ratios), a big circle running OFF-SCREEN (there's no scan clamp on the disc path today), and r=0/1 degenerate radii. Scene 1 DITHER (key 2): big circles + ovals through every FILL_* pattern (the plot_pat fallback). Scene 2 ZOOM (key 3): planet-style big fills under a zooming camera_ex (rotation 0) — the byte-identity test for the span fast-path under zoom (orbit's case). Pure function of the frame counter — byte-reproducible — so it pins the disc rasterizer for a clean profile AND validates the span-fill optimization pixel-identical. Not a game; a profiling + regression rig.

Handwork simulation

The EMBODIED half of sloop's production subsystem (docs/design/sloop-handwork.md) — the CDDA body-in-the-world handling loop The Cut skipped. You walk a workroom, harvest plants into a carried BASKET, then turn raw STALKS into trimmed FLOWERS two ways: by HAND at the BENCH you stand there LOCKED and TIME each cut on a bouncing meter — a clean cut makes a FINE flower (premium-grade); or load the MACHINE and walk away while it trims on its own at a fixed, always-COARSE quality. A machine is your first DELEGATE (one pure transform, run by your timed hands or the machine's fixed stamp; followers later slot into the machine's seat). The hook is the OPPORTUNITY COST: BUYERS arrive at the DOOR and WAIT — a PREMIUM buyer wants a few FINE flowers and pays by quality, a BULK buyer wants a cheap pile of anything — and they leave if you don't serve them in time. So standing locked at the bench COSTS you sales; the machine earns its keep by trimming the bulk while your hands chase the premium order. One body can't be in two places — that live choice is the game. Skill rises as you hand-trim, making FINE easier. WASD/arrows walk; Z harvest a ripe plant / pick up the basket / cut at the bench / load the machine / serve the buyer at the door; X drop the basket / collect the machine's output / leave the bench.

Interiors — a fill language for floor-plans

The indoor sibling of Lotfill (docs/design/interiors-brief.md): where lotfill fills the land between buildings, this fills the space INSIDE one building's footprint - believable house / shop / warehouse layouts. A floor-plan is a BOUNDED region generated wholesale from one hash-seed, so unlike lotfill's open-world scatter we MAY GROW: recursive BSP splits the shell into a room tree (bounded => recursion is legal). The thesis: rooms EMERGE, they are not a type list - partition() splits the shell into anonymous rooms, then a SELECTOR reads each room's AREA / FRONTAGE / ADJACENCY and lets the label fall out (largest-fronting-entry = living/shop/bay, smallest = bath/office, medium-on-an-exterior-wall = kitchen, the rest = bedrooms/storage); believability comes from the RULES, not hand-placed set-pieces. Building type (residential / commercial / industrial) is the top-level selector input, picked per cell from a zone field. The tabs (TAB to switch): PROGRAM = the DRIVER (default) composing shell->partition->circulation->fixtures->furnish over a grid of footprints; SHELL = the exterior envelope + the entry gap on the frontage wall; PARTITION = the recursive BSP room-split (the heart); CIRCULATION = doors through the shared walls - every split's wall gets a door, so the room graph is a TREE => every room reachable from the entry by construction (no orphans); FIXTURES = windows on exterior walls + doors on interior; FURNISH = props per room keyed by the emergent label. Honors lotfill's seams: pure fn of the hash-seed (deterministic, byte-reproducible), draw == query (room_at/solid_at IS the future collision seam for sloop), LOD gates drawing not generating, atoms read no globals. Inspection: 1-4 peel layers with live counts, G shows the BSP walls + entry markers, O tints the building-type field. WASD/ZX move, R new seed.

polystress

A deterministic torture test for the SOFTWARE polygon rasterizer (polyfill -> poly_fill_cov -> poly_inside -> plot_pat) — polyfill's sibling to trifill stress. 159 fills/frame across every path through the filler: three big concave 9-point stars (large fill AREA through the per-pixel even-odd test), a 70-cell grid of small spinning stars (polyfill COUNT / per-call setup), six sweeping road strips (convex tapering quads, exactly roadlab's fill_strip case), one checker-dithered concave star (plot_pat's fillp() patterned branch), and a giant mostly-off-screen quad (poly_clamp_scan). Everything is a pure function of the frame counter — no time, no random — so dumped frames are byte-reproducible run-to-run and build-to-build, which is the point: it pins the rasterizer for a clean profile (hit the ⏱ profile button) AND validates a rasterizer optimization pixel-identical (--dump + shasum before/after). Not a game; a profiling + regression rig.

The Cut simulation

A process-optimization bench — the 'tune a recipe for best quality / most money' itch (Schedule 1 mixing x Dwarf Fortress maker-skill x a demand curve), prototyped as a subsystem for the sloop product economy. Build a BATCH from an ORDERED sequence of reagents, watch THREE numbers move — QUALITY (how clean), STRENGTH (how potent), EFFECT (what it does) — then STIR it by hand for a purity bonus and sell to the client whose taste fits. Order matters: reagents synergize or clash with their neighbour, and SOLVENT cleans whatever crude thing follows it. The whole product is one pure function, so a hired worker runs the same bench at their own skill — the do-it-yourself -> manage arc. Skill levels up as you craft, unlocking recipe slots. Or DELEGATE: open CREW, hire someone, hand them your recipe as a standing order, then LEAVE for a few days and come back to a ledger (batches, spoilage, their quality vs yours, gross minus wages) — they earn while you're away, but a skilled hire costs a wage and morale, and your own stirred hands eventually beat theirs. MOUSE: click a reagent to append, a chip to remove, CLEAR resets; tap the stir bar when the marker is in the green for a purity bonus, SELL to market, click a client to sell, CREW to manage workers. KEYS: 1-6 add reagent, BACKSPACE pop last, SPACE stir, C crew, ENTER to market / sell to best client.

Transitions

The screen wipes that bridge two scenes, side by side over a live world. Ten: IRIS (a circle closes onto the hero, SNES Mario / Looney Tunes), CLOCK WIPE (a radial sweep, Star Wars), WIPE (a hard edge slides across), CURTAIN (top + bottom slabs meet), BLINDS (venetian slats snap shut), DISSOLVE (an ordered-dither pixel fade, Genesis/Sonic), FADE (dim to black), LUMA (a grayscale swirl thresholds in PIXEL-PERFECT via per-row spans — the GENERALIZATION: any grayscale 'image' is a transition, the shape becomes data not code), TRIANGLE (a wipe with symmetric triangle teeth — also a luma field: a ramp + a vertical tooth wave, monotonic so one span per row; saw vs triangle is just the waveform), and SLIDE PUSH (the new scene shoves the old one off-screen). The mask-based nine each play OUT, swap a sunny hilltop for a starlit cave at full black, then play back IN — the trick is one black mask whose shape encodes how-covered-are-we (iris=ring(), clock=arcfill(), dissolve=fillp() Bayer dither, fade=fade(), luma=threshold a grayscale field by coverage); SLIDE instead camera-shifts both scenes in one motion. A tour of the masking primitives, with a selectable easing curve (linear / in / out / in-out / back) — ease-back's overshoot is visible on the slide. Left/right pick, Z play, up/down speed, X cycle easing.

tristress

A deterministic torture test for trifill — which is poly_fill_cov with n=3, so it already inherits the polygon scanline span fill (one DrawRectangle per row). The measurement seam for a possible DEDICATED triangle rasterizer (sorted-vertex incremental edge walk, no per-row division): scene 0 BIG (key 1) = 8 large rotating triangles (per-row math over large area), scene 1 MANY (key 2) = a 26x16 grid of tiny triangles (per-CALL setup, where poly_clamp_scan's 4 matrix-inverts dominate). Pure function of the frame counter. Verdict so far: a tri-specific path isn't worth it (BIG 0.33ms / MANY 0.97ms, no real cart trifill-bound); the per-call overhead it would cut is shared by all software fills and better solved by a per-frame clamp-box cache. Kept as the rig + seam. See guides/engine-optimization.md.

finger drums ⚡2×audio

Play a drum kit BY HAND — the performance counterpart to the cabinet's step-sequencer boxes (808/909/cr-78). FIVE kits, TAB cycles them, each a matched LOOK + SOUND: ACOUSTIC KIT (a real drumset in perspective — kick, snare, INSTR_MEMBRANE rack + floor toms, hats, crash, ride); MPC PADS (a 4x4 grid of an 808-style electronic kit — boom kick, noise snare, square cowbell, retriggered clap); PIKUNIKU (the drums are little bean-creatures with big eyes and stretchy legs that KICK when struck, on pastel hills — bouncy toy/chiptune voices + an INSTR_MALLET sparkle); MAC DEMARCO (the kit re-themed warm & woody, voiced soft and dead, run through tape wow/flutter + chorus + detune — the woozy bedroom-tape warble); and MAC - TAPE (a lo-fi drum-machine version, same woze + a touch of cassette bitcrush, faded vintage palette). Touch hardware gives position, never pressure, so VELOCITY comes from WHERE you hit: high = soft, low = hard (8 levels). Every finger strikes independently (multitouch). Keyboard fallback hits mid-velocity, SHIFT accents: kit = F/G hats, T/Y cymbals, J snare, I/K/M toms, SPACE kick; pads = 1-4 / QWER / ASDF / ZXCV. A USB-MIDI pad controller plays any kit with real hardware velocity (GM drum map). TAB cycle kit, H help.

Lotfill — a tiny world from content atoms

The WORKBENCH for the street-level CONTENT language (docs/design/streetlevel-content.md): where roadnet/procplaces build the partition (roads, lots, the land between cities), this FILLS it. Each fill-rule is an ATOM you inspect as a tab (TAB to switch); the SAME atom fn runs in an isolated tab AND in the WORLD driver, so what you tune is bit-for-bit what ships. The default WORLD tab is a tiny self-contained worldgen: a SELECTOR (world_kind_at) reads terrain + an urbanization field and picks an atom per region - wild land -> scatter (forests/meadows), farmland -> rows (fields), towns -> footprint (buildings) - composing one coherent world (no roadnet/worldgen dependency; G draws the selector map: wild green / farm yellow / city red). The seven-atom set (TAB through them): SCATTER = the continuous-cover fill-mode (no parcel/identity): cover_at(x,y) is a FIELD (elevation gates water/beach/rock, then a warped fbm biome -> bare/grass/meadow/forest x a density field for clearings & flower clumps), and the renderer SCATTERS trees/bushes/flowers per jittered-grid cell, each a pure fn of its own cell + seed (lattice instances are local; grown sets tear at chunk borders) - infinite, seam-safe, byte-identical for a seed; the same cover_at answers sloop's collision later (screen == collision). ROWS = a BOUNDED fill-mode: a coarse parcel grid of fields, each planted with rows of one crop (plough/corn/wheat/vineyard by per-parcel hash -> crop + orientation + spacing) + a hedgerow; rows_fill() fills ONE region and the driver tiles it. FOOTPRINT = buildings (the GTA street): a block grid carves streets, each block's PERIMETER lots front a street by construction (centre = courtyard/parking, no orphan interiors), and one footprint_fill() makes house/shop/tower from a ZONE field (residential/commercial/downtown) + hash - the types emerge, none enumerated. BORDER strokes a region edge (hedge/fence/wall), PAVE flat-fills a surface (asphalt+parking-stalls/plaza/gravel/sports-court), STAMP drops one authored composite (fountain/statue/well/obelisk); all tiled by a demo_grid() that IS the subdivide primitive. Inspection (every tab): 1/2/3 peel layers with live counts, G shows the lattice/parcel/block grid or selector map, O cycles the driving field overlay (cover-kind / density). WASD/ZX move, R new seed.

rampkit

A geometry SANDBOX for the interchange-DSL idea (docs/design/interchange-dsl.md): a road ramp is built from TWO PORTS (an attach point + a tangent direction) plus a TYPE — DIRECT / FLYOVER / LOOP all fall out of ONE closed-form constructor, with no per-shape coordinates. Ports are drawn as arrows; the orange ramp re-solves to whichever pair + type you pick. Proves 'describe junctions declaratively, not by hand-placed geometry' in isolation before porting back to interchange.c. Controls: LEFT/RIGHT cycle port A, UP/DOWN cycle port B, SPACE cycles the ramp type, F flips the DRIVE side (the loop mirrors). Press N for the NEST-SOLVE demo: two non-concentric loops where a relaxation solver finds the inner radius so the two nest at a target clearance (LEFT/RIGHT adjust the gap). See docs/design/interchange-dsl.md and docs/design/road-geometry-refs.md.

roadlab

The FOUNDATION sandbox for the interchange geometry DSL, built on the road-geometry research (docs/design/road-geometry-refs.md). Lane-accurate roads (drive-on-right via a DRIVE constant) with per-lane direction arrows; ports anchored to REAL lanes (a port = a lane + its travel direction); and ramps built as ARC-SPLINES (LINE->ARC->LINE — the OpenDRIVE reference-line model, minus the XML) instead of free Beziers, so they offset and nest cleanly. Supersedes rampkit (which proved the port->ramp abstraction on Beziers). Milestone 1: pick two ports, watch the arc-spline ramp round the corner between their lanes. Controls: LEFT/RIGHT cycle port A, UP/DOWN cycle port B, [ / ] arc radius, F flips DRIVE. Next: clothoid joints (drivable feel) and concentric-arc nesting. See docs/design/interchange-dsl.md.

acoustics probe

v3 acoustic-zones PROBE (spatial.md): a little guy walks rooms to hear where the API hurts, hand-wired against existing knobs only. ARROWS to move. FOOTSTEPS change tone by ground (tile click / carpet thud / wood knock / grass rustle) and carry the room's reverb (absorption: bright tile vs dead carpet). Each ROOM sets the master reverb (zone) — crossing rooms re-applies it (listen for the abrupt switch = the 'rideable reverb' gap). A RADIO (left room) + MACHINE (right room) emit continuously; a wall between you and one muffles it (occlusion: raycast -> note_cutoff + note_vol), the doorway opens it up. Findings: cart header + STATUS open item.

amp noise ⚡2×audio

The showcase for amp_noise() - the OPTIONAL rig-noise floor. An electric guitar through a tube amp is never truly silent: a bed of HISS (tube/thermal noise) plus a 50/60 Hz mains HUM (the single-coil buzz) sits under everything, even with no note playing. amp_noise() models that floor - but it is entirely opt-in (a fantasy console is pristine by default), so the headline is the A/B: press N (or SPACE) to toggle the FLOOR on/off and hear the rig breathe versus dead-silent. The HISS and HUM sliders dial the floor (0,0 = off); M switches mains 50 Hz (EU) / 60 Hz (US); 1..4 play chords that sit ON the floor. A tube-amp face glows its 12AX7 power tube and dusts hiss speckle over the grille while the floor is on. Some tracks want this grime, some want the silence - that is the point, it is a choice not a default. Built on the boutique-pedals roadmap; pairs with a noise gate (next) to clamp the floor between notes.

dijkstra maps

PROBE (probe-carts.md): 'the incredible power of Dijkstra maps' (RogueBasin) made playable — is a Dijkstra/flow-field map worth owning, the AI companion to astar's single path? One flood-fill (every floor cell = distance to the goal) drives three behaviours, rendered as a live contour-ring heatmap with downhill flow arrows. APPROACH: agents roll downhill to the goal, routing around walls. FLEE: negate the map and re-flood -> agents flee via real escape routes, not into dead ends. HUNT: add a 'seek gold' map to a 'dread the monster' map -> agents grab loot while dodging a monster that itself hunts them by rolling downhill on a distance-to-agents map. ARROWS drive the goal (or the monster in hunt), L/R-drag paint & erase walls, TAB cycles mode, F toggles flow arrows, R/C/G randomize/clear/rescatter.

flank shooter

Top-down tactical AI -- a squad that isn't dumb (a testbed for a GTA1 / Hotline-Miami enemy brain). Four ideas: COMMUNICATION -- a shared blackboard; the instant any enemy sees you it calls your position to the whole squad and blind ones converge (knowledge decays, so break contact and they search your last-known spot). FLOW FIELD -- a Dijkstra map flooded from your last-known cell, so they approach AROUND cover, not into walls. HEATMAP / FLANKING -- your aim projects a danger cone; enemies score firing spots to AVOID the cone, so they peel off and hit you from the sides and behind. COVER -- XCOM-style FULL cover (grey: blocks sight + bullets) and LOW cover (orange crates: shoot OVER them, but a shot from the side they face has ~50% to be absorbed); both sides seek low cover that faces the enemy. THREE ENEMY TYPES with distinct tactics, visible at once (glyph = type, colour = state): R rusher charges in close and sprays, C camper holds cover at long range, F flanker circles to your sides. SUPPRESSION -- campers anchor and pour inaccurate fire to PIN you (you slow to a crawl + your aim shakes) while rushers/flankers maneuver: emergent fire-and-maneuver. STEALTH -- hold Shift to sneak (slower, quieter, lower profile, harder to detect); you have limited vision (fog of war), enemies you can't see leave a dim last-seen ghost, and the squad investigates your last-known spot (?) while you slip away elsewhere. DETECTION is graded -- calm/suspicious/alarmed; a guard hears a NOISE and walks over to check, then gives up and returns. Your loud gun makes noise that draws the room; a silent knife (right-click, close range) does not -- so loud vs quiet is the core stealth choice. A DIFFICULTY PANEL (O) has easy/normal/hard presets + live sliders for squad size, damage, fire rate, accuracy, sight, suppression and healing; pick up green health packs (easy also slowly auto-heals out of combat; hard has neither). WASD move, Shift sneak, mouse aim, L-click gun, R-click knife; O difficulty, H heat, L comms, V reveal-all, TAB spectate, R reset.

fxmod ⚡2×audio

The showcase for fx_mod() / fx_lfo() - the MODULATION layer over effects (the synth-rack 'CV into an effect'). Effects keep their own knobs; this RIDES a curated, sweep-safe one under a control signal, the way LFO_TIMBRE rides an instrument macro. A held saw drone runs through the master effects; 1..3 pick the TARGET param (filter cutoff / drive / shimmer mix), then choose how it's driven: L = engine LFO (fx_lfo(): set once, the engine sweeps it), C = CV by hand (fx_mod(): the cart pushes a value every frame - what modrack does), O = off (the param sits at its static baseline). RATE/DEPTH/CENTER shape the sweep; the big bar shows the value being written. Two APIs, one job: fx_lfo is fire-and-forget, fx_mod is the per-frame sink you drive from your own LFO/envelope/sequencer. Only cheap params are exposed, so it can never reconfigure a buffer effect into a stutter. H help. (ADR 0018.)

generation loss ⚡2×audio

The showcase for dropout() - the VHS / Generation-Loss FAILURE knob. A self-playing wistful EP loop runs through the full degraded-cassette chain: crush() (bit + sample-rate reduction) into tape() (wow/flutter/saturation) into dropout(). The new piece is dropout: a sample-and-hold clock randomly TRIGGERS momentary tape-catches where the whole mix stumbles - drops in level AND goes dull from HF loss - then recovers fast, exactly like a tape dubbed one too many times. Three sliders: FAILURE (how often the tape catches), DEPTH (how hard each catch drops), DEGRADE (the bit-crush + tape grime baseline). A VHS tape-transport display turns its reels and tears its tracking when a catch fires. SPACE pauses the loop; H for help. Built on dropout() + the modulation kit's sample-and-hold (mod_sh) from the boutique-pedals roadmap. Part of the lo-fi / effects family.

interchange

A geometry SANDBOX for roadnet2's road interchanges — how a crossing road meets a highway, in fake-3D (the crossing road is drawn OVER the highway, reading as an overpass — grade separation without real z-levels) plus a library of connection types built from ramp curves. A horizontal highway and a hand-placed crossing road, with the ramps grown and eyeballed in isolation before porting the drawer into roadnet2. The eventual interface: given two crossing roads + a type, draw the ramps. Controls: T cycles the type (OVERPASS / DIAMOND / CLOVERLEAF / TRUMPET), LEFT/RIGHT rotate the crossing road, UP/DOWN ramp size, H hides the HUD. Diamond + overpass are solid; cloverleaf/trumpet are first-draft. See docs/design/roadnet2-plan.md.

lfoshapes ⚡2×audio

The showcase for the unified LFO_SHAPE_* vocabulary - the modulator waveform, shared across the whole engine (voice LFOs via lfo_shape()/note_lfo_shape(), tremolo/autopan, and fx_lfo). One held saw note runs an LFO; press 1..8 to switch its WAVEFORM live - sine / square / tri / saw / ramp / optical (the Univibe bulb throb) / S&H (sample & hold) / random (filtered walk) - and watch the trace redraw while the yellow dot tracks the value right now. D flips the destination between PITCH (vibrato) and CUTOFF (a filter wobble); -/= set the rate. The expressive payoffs: S&H on PITCH is a random-step arpeggio, SQUARE on CUTOFF is a stepped two-state filter. The stateful shapes are deterministically seeded (--det reproducible). H help. (STATUS #39.)

lurk rpg

The predator dungeon -- you're @, the monsters think (RogueBasin: A Better Monster AI / Roguelike Intelligence / prevent A* jams). Each monster runs a STATE MACHINE, glyph coloured by state: WANDER (grey) until it SEES you (line of sight + range) or HEARS you near; HUNT (red) rolls downhill on a Dijkstra map flooded from you, shortest path around walls; SEARCH (yellow) follows your decaying SCENT TRAIL when it loses sight; FLEE (blue, wounded) rolls downhill on the negated map = smart retreat. A hurt monster SHOUTS (a horn) and snaps nearby monsters to HUNT. Pursuers take different routes and never conga-line (the simple A*-jam fix). Species differ -- rats skittish, orcs fearless, hounds fast trackers, goblins call for help. Every bark/stab/yelp/howl is panned by position so you hear the pack circle you. Arrows/WASD move, bump a monster to attack, R restart.

needs

Need-driven (utility) AI, the @ colony (RogueBasin: Need driven AI + Variety in NPC behavior). Seven creatures each carry four draining needs (hunger, thirst, energy, social); every decision they score each need by urgency = (100-value)*weight and go satisfy the most urgent -- food f, water ~, a bed =, or the nearest friend. No scripts: behaviour falls out of the meters. PERSONALITY (per-creature weights + drain rates) makes a glutton, camel, sloth, loner, socialite live visibly different lives from one rule set. Pathing reuses Dijkstra fields (one per resource). A thought-bubble glyph over each creature shows its current goal; click one to inspect its need bars. SOUND: every satisfied need rings a short pentatonic motif (munch/gulp/snore/chime), pitched per creature and panned by position -> the colony's resolving needs become a generative texture. R reseeds.

pasture

A living world on one day/night clock (RogueBasin: townsfolk AI + Denizen Herding). TOWNSFOLK follow a daily SCHEDULE -- sleep at home, gather at the well, work the field, drink at the tavern by the hour -- with personalities bending it (a drunk haunts the tavern, a farmer never leaves the field); a glyph over each head shows the activity. SHEEP HERD by boids (cohesion + alignment + separation) and FLEE the wolf, harder the moment it HOWLS (sound drives behaviour). The WOLF hunts the nearest sheep and howls on a timer; the flock bolts. The clock drives a true-colour sky gradient (rectfill_rgb), an ambient chord that shifts with the phase, a bell on the hour, and bleats/howl panned by position. Click a townsperson to inspect, H to force a howl, R to reseed.

roadnet 2

A VECTOR-NATIVE rebuild of roadnet, started from roadnet's clean rung-1..3 baseline: the same elegant spline-highway core (terrain-aware Catmull-Rom roads between ranked hub/town cities over an infinite deterministic heightmap) with the rest deliberately UNFILLED — the clean foundation. The deeper-road fill-in (collectors / access / cul-de-sacs / buildings) is being redone graph-first this time: ONE representation (spline edges in a graph), ONE query (road_at = nearest edge within its class half-width, generalising arterial_at downward), buildings on edges, warped-grid curvy deeper roads, and NO modular street field — the dual field+graph representation is what made v1 messy. Plan + build order: docs/design/roadnet2-plan.md. Controls (L0 core, same as roadnet): drag the panel sliders, ROLL / EXPLORE; then arrows / WASD pan, mouse wheel zooms, SPACE jumps to fresh scenery, R new seed, M reopens the panel, G cell-border overlay, H hides the HUD.

shimmer ⚡2×audio

The showcase for shimmer() - a reverb with an OCTAVE-UP pitch-shifter wired into its feedback loop (the Strymon BlueSky / Brian Eno sound). Each pass through the reverb, the wet tail is tapped, pitched up an octave, and fed back in - so a held chord doesn't just bloom, it CLIMBS, rising into a glassy crystalline pad. A held organ chord feeds the shimmer; 1..4 change chord (Cmaj/Am/Fmaj/G). The SHIMMER slider is the climb: low = a plain reverb bloom, high = an endless ascent (a 2-grain overlap-add octave-up recirculates, tanh-governed + DC-blocked so it can't run away). SIZE/DAMP/MIX set decay length / tail darkness / dry-wet. Rising sparks visualise the ascending octave tail - more SHIMMER spawns more, climbing faster and brightening as the energy rises through the octaves. The trophy of the boutique-pedals roadmap (Primitive 2: a real-time bus pitch-shifter).

sightlines

PROBE (probe-carts.md): is a tilemap line-of-sight / FOV primitive worth owning in the engine? Two candidates on the same occluder grid. SINGLE-RAY LOS — one Bresenham walk answers 'can A see B?' (enemy vision / stealth / aim / audio occlusion); each guard draws a ray to the eye, red when it has line of sight. FIELD OF VIEW — recursive shadowcasting reveals everything the eye can see, walls casting shadows (lighting / fog-of-war). ARROWS move the eye, L/R-drag paint & erase walls, TAB toggles LOS<->FOV, wheel sets FOV radius, C clears, R randomizes. Generalizes the acoustics-probe raycast beyond audio.

spatial

Sound that lives in the world — the spatial-audio API (v1 per-voice + v2 emitter buses). You are the EAR (arrow keys to move). A UFO flies across the upper lane as a v2 EMITTER: a sustained tone through SHIMMER reverb, positioned via instrument_pos/instrument_motion so the WHOLE effected bus moves — you hear the Doppler bend the pitch through the entire pass and the glassy tail sweep with it. A CAR loops the lower lane (v1 note_motion) for the simpler per-voice whoosh; a SUITCASE RHODES (bottom-left) arpeggiates EPIANO via positioned hit_at; CLICK/TAP fires a one-shot blip AT that spot. listener()/note_pos()/note_motion()/hit_at() position voices; instrument_pos()/instrument_motion() position a whole effected bus. Dormant and byte-identical until you call listener().

tempo

Turn-based time scheduling by SPEED -- the roguelike energy-scheduler (nadako's turn-scheduling rant). Naive roguelikes loop 'for each actor: act()' so everyone moves at one rate; real ones schedule by energy/speed so a fast actor acts more often, interleaved. Each actor here has a 'next turn' time; the scheduler always runs whoever's next is soonest, then pushes their next turn out by COST/speed -- higher speed = sooner and more often (the same idea as energy accumulation, expressed as next-event times so the ORDER is drawable). The payoff is the NEXT ribbon up top: the upcoming ~14 turns in order. Press H to re-speed yourself (slow/normal/fast/blink) and watch the ribbon rewrite -- at blink you take two or three steps between a troll's single lurch. Five monsters at different speeds (slow troll -> fast hound). Arrows move/bump to attack, H change speed, R reset.

univibe ⚡2×audio

The showcase for univibe() - the 60s photocell vibe (Univibe / Shin-ei Uni-Vibe, the Machine Gun / Bridge of Sighs wobble). It's the SAME 4-stage allpass chain as the phaser, but swept by an OPTICAL LFO instead of a sine: a lightbulb glued to a photocell glows slowly bright then snaps dim, so the sweep is asymmetric and liquid where a sine phaser is even and clinical - that asymmetry IS the sound. A slow organ chord loop runs through the vibe; the LAMP in the middle is the live LFO (watch it ease up, then drop fast) and the curve strip draws one cycle of the shape. Press P to A/B OPTICAL (univibe) vs SINE (plain phaser) at the same rate/depth, so you hear only the difference the bulb makes. 1..4 play chords (Am/F/C/G); RATE/DEPTH/MIX sliders ride it live; H for help. The first cart built on the modulation kit (mod_optical) from the boutique-pedals roadmap.

varispeed ⚡2×audio

The showcase for varispeed() - variable TAPE playback speed of the whole mix (the Chase Bliss MOOD 'clock' / a turntable brake), ported from navkit's half_speed. A self-playing riff runs the whole time; varispeed re-reads the final output at a chosen speed: 1.0 = normal, <1 = slower (pitch DOWN + time-stretch), >1 = faster (chipmunk). The applied speed GLIDES (tape inertia), so it dives and spins back smoothly. Hold SPACE for a TAPE-STOP divebomb (the speed brakes toward a halt; release to spin back up); the SPEED slider bends it by hand (0.25x..4x, center 1x); 1..4 change the riff. Two reels spin at the live speed - watch them crawl on the dive. H for help. The last item from the boutique-pedal lists.

voice stress

Hold up to SOUND_VOICES (32) of the hungriest engines at once and watch/listen for crackle. Crackle is a real-time audio-thread underrun, so the honest test is to RUN THIS AND LISTEN; the on-screen fps + voice count + a constant-speed sweep reveal CPU starvation too. UP/DOWN sets the held-voice count (starts MAXED — it's a stress test), [ / ] cycle the engine (the self-oscillating BOWED/BRASS/REED/PIPE waveguides are the true worst case — full delay-line DSP every sample, per voice), R retriggers. Built to verify the 16->32 voice bump: on a dev Mac the full 32-voice BOWED wall costs ~10% of one core.

wfc terrain

Wave Function Collapse (simple tiled model) generating terrain, then auto-tiling for smooth transitions. Every cell starts in superposition; OBSERVE collapses the lowest-entropy cell, PROPAGATE ripples the constraint out (a level may only touch levels within +/-1, so water never borders forest -> beaches must appear). A neighbour-agreement bonus grows coherent islands & bays instead of noise. Renders two ways: BANDS (flat colour per cell -- the hard-edged worldgen look) and SMOOTH (marching-squares auto-tiling: each level's coastline drawn over the level below). B toggles between them = a live before/after of generation (WFC) vs transitions (auto-tiling). Opens on a finished map; SPACE step, A auto, R regenerate (watch it collapse).

combo ⚡2×audio

A vintage combo amp you plug a guitar straight into - the 'cab story' made playable. An amp/cab isn't new DSP: each VOICING is a preset BUNDLE of effects we already ship - instrument_drive() + a DRIVE_* waveshaper, instrument_eq(), and glue() (power-amp sag) - pinned as the output stage that colours whatever the strings play. Five voicings sweep the canon: CLEAN (black-panel sparkle, soft clip), CHIME (British asym warmth + airy top), CRUNCH (the Plexi-style rock tone = the effects-recipes 'guitar-amp' anchor: ASYM 0.55 + mid-forward EQ), HI-GAIN (hot-rodded, scooped mids, hard clip + heavy sag), LO-FI (broken/boxy wavefolder honk). GAIN scales the voicing's drive, BASS/MID/TREBLE bend its EQ curve (+/-12dB), MASTER = how hard you pick in (keybed velocity), SAG = the glue compressor. The tube glow brightens and reddens with gain, the VU needle tracks, the grille shudders on loud chords - all from a cart-side level proxy (the engine exposes no output meter). Plays INSTR_GUITAR through the shared keybed: white A S D F G H J K L, black W E T Y U O P, Z/X octave, 1-5 pick the voicing (or drag the VOICING knob), drag the tone knobs, M demo on/off. Multitouch + USB MIDI.

fretboard ⚡2×audio

A multitouch fretted string instrument — TAP a string at a fret to pluck it, tap several strings at once and you get a CHORD: the chord is your finger GEOMETRY, not a button you press. The payoff of the monochord experiment, and the honest version of pedalboard's chord buttons (here you actually form the shape). Six strings, standard tuning E A D G B e; frets quantize the position so you land in tune. TAP a string @ a fret = pluck it; DRAG across the strings = a strum (each sounds as you cross it); slide along a string = re-fret. SPACE strums all six at their held frets. DESKTOP crutch (you can't multitouch a mouse): hold 1-6 for an open-chord shape (Em G C D Am A), then SPACE or drag to strum it — on a phone you fret the shape by hand instead. INSTR_GUITAR. A full six-finger chord + strum exceeds the iPhone 5-touch cap, so it leans desktop/iPad.

grain clouds ⚡2×audio

The showcase for grains() - a GRANULAR DELAY ported from navkit. It captures the live signal into a buffer, then sprays scattered, overlapping windowed GRAINS of the recent past back out as an evolving cloud (a Cosmos-style ambient texture). A soft pad chord feeds the cloud the whole time; the headline move is FREEZE (F or SPACE) - stop capturing and loop what's there forever, so you play a chord, freeze it into an infinite shimmering pad, then solo OVER your own frozen self. Six sliders ride the cloud live: SIZE (grain length), DENSITY (grains/sec, sparse to dense wash), POSITION (deep past to live edge), SCATTER (the random-spread 'evolving' knob), FEEDBACK (self-feeding cloud), MIX. Each dot on screen is a grain reading the buffer; the green bar is the capture head, which halts when frozen. Press 1..4 for chords (Cmaj7/Am7/Fmaj7/G), H for help. Built on grains() / grains_freeze() - reorderable as FX_GRAINS in the pedalboard. Part of the effects-bus / pedalboard family.

monochord ⚡2×audio

One string, no frets — your FINGERS are the bridges, and the LENGTH of each segment IS its pitch (a string halved sounds an octave higher). The gesture behind the đàn bầu, the diddley bow, slide guitar, and Pythagoras's monochord. DRAG on the string to place/move a bridge; with two fingers the segment BETWEEN them sounds — spread apart = lower, squeeze together = higher. FLICK across the string (from above/below) to PLUCK the segment you cross — pluck outside the bridges for the short 'wrong-side' overtone, pluck several segments for a chord on one string. A PD oscillator, so a ringing note GLIDES as you slide a bridge (the đàn bầu bend). Faint ticks mark the just-intonation points (1/2 octave, 2/3 fifth, 3/4 fourth). SPACE plucks the open string. Two bridges at once needs a touchscreen/multitouch trackpad; the desktop mouse is one finger. An experiment in fretting-by-finger-position (built on pointer.h).

roadnet

A SPLINE arterial network over an infinite, deterministic heightmap — the curved, non-axis-aligned roads procgen-places parked as 'the wall' (docs/design/roadnet.md). The crack: a NODE-LATTICE spline is local even though a grown one isn't. Each coarse cell hashes to at most one POI node (on habitable land); a link between two nodes is a Catmull-Rom whose four control points — node(C-d), node(C), node(C+d), node(C+2d) — are every one a pure function of cell coordinates, so any chunk recomputes the identical curve with no global pass. The network is CONNECTED by hierarchy (the 'Main Rib'): white HUBS on a coarse lattice form a continuous highway backbone, and red/orange TOWNS branch into it with feeders to their nearest hub, so nothing is orphaned. It all streams around the camera over layered-noise terrain bands and rivers (worldgen's heightmap); links drop wherever the straight line of land isn't passable, so water cleanly divides regions until v2 bridges. Opens on an INTRO PANEL — a glass strip of sliders (hub gap, town gap, hub/town density, wiggle, diag, water) over the live full-screen world, so dragging a slider re-rolls the world live behind it; ROLL reseeds, EXPLORE dismisses it to pan. Rung 1 of the eventual road layer for sloop's world; sibling to trackgen (the finite single-track cousin). Controls: drag the panel sliders, ROLL / EXPLORE buttons; then arrows / WASD pan, mouse wheel zooms in/out a bit, SPACE jumps to fresh scenery, R new seed, M reopens the panel, G toggles the cell-border overlay (the seam test), H hides the HUD.

added 2026-06-13

caustics

Water light effects and a two-part lesson in DISPLACEMENT MAPPING: warp WHERE you read a colour and the picture appears to ripple. Press TAB to flip between the same idea done two ways. FAKED (the N64 way): the displacement is a few scrolling SINE waves computed on the fly over a procedural pool floor - no memory, no physics, basically free, exactly how Mario 64 and Ocarina of Time faked moving water on a GPU that could not run a shader. REAL (displacement mapping proper): the displacement now comes from a real HEIGHT-FIELD WATER SIMULATION - two ping-pong buffers holding the surface height, each cell becoming the average of its neighbours minus its previous value times a little damping (the wave equation, the previous frame feeding the next is the feedback), and the surface SLOPE steers where each pixel LOOKS UP A REAL CAPTURED IMAGE (src[]); drop a stone and the rings expand, reflect off the walls, cross and interfere, and fade - the classic demoscene 2D water (Hugo Elias). Same umbrella technique, two ways to make the map: a formula, or a simulation you can poke. Everything painted in 24-bit true colour through pset_rgb / rectfill_rgb. Three floor textures / source images: pool tiles, a sandy tropical bottom, and a high-contrast checkerboard whose straight lines visibly BEND so you see the distortion itself. TAB switch FAKED/REAL, drag the mouse to push the water, CLICK to drop a stone, C toggles caustics (the light web), W toggles waves (FAKED), UP/DOWN strength, [ ] pixel size, SPACE freezes, 1/2/3 or LEFT/RIGHT switch floor. Companion to shadelab.

DJ Filter ⚡2×audio

The legendary one-knob mixer filter (Allen & Heath XONE:92, Pioneer DJM) and, at the screaming end, a Sherman Filterbank - the showcase cart for the master filter() bus, where the EFFECT IS THE INSTRUMENT. A bright four-on-the-floor house loop (detuned-saw arp + lush pad + rolling sub, cribbed from groovebox) plays itself so both hands are free to RIDE the filter, exactly like spacecho rides the echo. THE control is one BIPOLAR knob, center = OPEN (bypass): turn LEFT and a lowpass closes 18kHz->150Hz into a muffled thump; turn RIGHT and a highpass opens 20Hz->6kHz into a thin telephone. The RES knob cranks the resonant peak into acid-scream territory. A live filter-RESPONSE CURVE up top is the centerpiece - watch the slope tilt and the peak rise as you sweep, with the cutoff marker sliding along the log-frequency axis and a FULLNESS bar that dims as the mix gets dark. The BUILD button is the money shot: a breakdown into an 8-bar filter-sweep riser with rising resonance and a clap roll, then the DROP snaps wide open with a bang - the genre's signature gesture, the reason the filter exists. Controls: drag the big FILTER knob (or LEFT/RIGHT arrows) and the RES knob (or UP/DOWN); BUILD button or X triggers the riser; BYPASS button or Z A/Bs the filter off vs on.

enginelab · dyno ⚡2×audio

A car-engine sound DYNO and synthesis workbench (the next-gen voice for sloop). An engine isn't a note - it's a FIRING RATE: ~15 Hz of distinct thuds at idle climbing to ~150 Hz of buzzing tone at redline, and that sweep is the whole illusion. One master number (chug_hz) drives every layer so they stay harmonically locked: a saw BODY pinging a resonant lowpass (each edge = one combustion puff), a FIRING tremolo at the chug rate that speeds up with the revs (sloop's is stuck at 9 Hz - the #1 thing that reads as 'synth' not 'engine'), a throttle-led exhaust RASP, an INTAKE/turbo-whistle bed, DRIVE saturation that snarls under load, an idle LOPE wobble, and an overrun BURBLE crackle when you lift. Seven engine kinds (electric whine, gas, diesel clatter, steam chuff, screaming race + turbo, nuclear hum, potato-potato tractor), each a distinct recipe. Hold UP/Z/SPACE to rev, LEFT/RIGHT switch kinds, 1-7 toggle each layer live to hear what it adds, I ignition, L free-rev vs under-load, M auto-rev demo.

eq

A 2-band shelving EQ that can BOOST as well as cut - the library's first effect that can lift a band (the SVF filters only cut). A SAW bass + a bright SQUARE lead loop play; drag the LOW (~80 Hz) and HIGH (~6 kHz) faders +/-12 dB each and watch the response curve bend - up = boost, down = cut. Route the EQ over the WHOLE mix (eq) or just the BASS (instrument_eq), or hit AMP to stack DRIVE_ASYM + a mid-forward EQ for a guitar-amp tone. A cycles the route, B toggles AMP, arrows nudge each band.

floorwalker

Walk a real Floorplanner floorplan as a top-down level. An .fml file is converted by data-tools/fmltools/fml2cart.js into walls (with doorways as walkable gaps and windows that block), room floors tinted per role, and furniture placed as oriented boxes. Each piece of furniture is a real top-down pixel sprite baked from Floorplanner's CDN render by data-tools/fmltools/fml-assets.js (downscale + saturate + outline + palette-quantize to pico32) and embedded by data-tools/fmltools/fml-sprites.js, drawn scaled to its real footprint and rotated. Segment + oriented-box collision, scanline room fills, camera follows you across the building, draw is camera-culled for 1000+ items. WASD/arrows to move, T toggles furniture sprites vs boxes. A pipeline demo for turning house plans into playable Hotline-Miami-style space.

groovebox ⚡2×audio

A tiny melodic / progressive-house box that plays itself so both your hands are free to ride the SUMMED-BUS effects - the half a pedalboard can't show (a chain runs ONE guitar; this sums six looping voices into one master, then sculpts the whole mix). A 6-row x 16-step grid (kick/clap/hats/bass/ARP) sweeps off the beat() clock; a lush sustained PAD on a slow minor progression breathes under a cascading arp lead. The headline is PUMP - a REAL summed-bus sidechain: the kick ducks the WHOLE mix every beat (the pad inhales and exhales; watch the PUMP meter). GLUE is the same engine compressor with no trigger - the mix squashed as one lump (PUMP and GLUE share the master comp, so raising one releases the other). The rest of the rack: CRUSH (summed bitcrush), a 3-band EQ (LO/MID/HI), TAPE, SPACE (reverb as a real master INSERT), a bipolar FILTER (the DJ filter - center open, ride it down to a muffle / up to thin, resonance rising as it closes), and an ORDER toggle that moves reverb before/after the crush - CRUSH>VERB is clean space on a gritty mix, VERB>CRUSH crushes the wet tail (grainy/vaporwave). TAP/DRAG cells to edit, WASD+Z cursor, arrows = tempo.

ondes martenot ⚡2×audio

The 1928 ribbon synth (Radiohead, film scores, Messiaen) - a two-hand upgrade to the theremin, played MOSTLY on the RIBBON: drag it for continuous pitch (X) while the HEIGHT is the swell (Y) - a real theremin volume hand, the glowing orb rising as it gets louder. ONE eerie voice rings the whole time, plus a DETUNED TWIN that beats against it (the haunting shimmer), a slow analogue pitch-drift, a little drive and an ensemble chorus - deliberately NOT a clean synth. la TOUCHE D'INTENSITE (the left lever) is the dynamics hand: it drives note_vol AND note_cutoff (harder = louder + brighter), rides the swell for the keyboard, and overrides the ribbon's Y when you grab it with a second finger. The CLAVIER (piano) plays tempered notes; drag UP on a held key for VIBRATO (the key-wiggle). The combinable TIMBRE stops O/C/G/N are summed live into one drawn cycle (wave_set) + an S breath layer. The four DIFFUSEURS are the loudspeakers as reverb colour (note_reverb live + the reverb bus): Principal (dry), Resonance (spring), Metallique (a bright gong shimmer, the default) and Palme (a long string-halo). Plays three ways - TOUCH (two hands: touche + ribbon), MOUSE (one pointer), or the computer KEYBOARD: GarageBand note layout (A S D F... whites, W E T Y U... blacks, labelled on the keys), Z/X octave, UP/DOWN ride the touche, and the NUMBER ROW works the buttons (1-5 stops, 6-9 diffuseurs).

pd bass ⚡2×audio

The upright bass's fingerboard, voiced on the Casio CZ phase-distortion engine (INSTR_PD) instead of a modeled string. The whole point of the swap: INSTR_PD is an OSCILLATOR - it sustains while held and glides BOTH ways - so where the bowed-string upright could only fret-walk downward, this synth bass does a TRUE smooth continuous slide, up and down, no re-pluck, no fret click (verified: it bends a held note down cleanly, +0.9 cents, where the waveguide stuck). Same string interactions as the upright: press a string to pluck a note (snaps to a clean semitone for in-tune starts); slide LEFT/RIGHT to glide the pitch continuously in either direction; PULL the string up or down to bend it (signed - up sharpens, down flattens - and the slide position freezes while you pull, so only the bend moves the pitch); start a drag in the open gap next to a string and sweep THROUGH it to PICK it (press ON a string grabs/frets, press in the gap picks). One pluck articulation (no arco/slap), and ONE TIMBRE slider down the right edge runs the PD distortion macro live from CLEAN (bottom) to BUZZY (top) - the signature CZ resonant edge, sweepable while a note rings. A plucky CZ bass patch on the RESO TRAP wave (fast attack, sustains while held, releases on lift; the morph macro gives the CZ strike sweep). A toggleable backing DRUM LOOP (SPACE, or the DRUMS button) - a bouncy boom-bap kick/snare/hat at 96 bpm - to play the bass over. Range E1-G3. Play with mouse or a phone tap, or the computer keyboard (GarageBand musical-typing map, A = E1; Z / X shift the octave). Dark synth panel with four glowing strings (low E drawn thickest) that deflect as you bend.

pedalboard ⚡2×audio

An electric guitar you PLAY through a CHAIN of stompboxes you BUILD - the showcase for fx_order(): the order pedals sit in the chain is the order the engine runs them, so moving a pedal actually changes the tone (bitcrush BEFORE vs AFTER eq sounds different). Tap '= PEDALS' (top-left) to open the palette - a tray of 9 effects drawn as little icon+name chips (BITCRUSH, EQ, CHORUS, PHASER, FLANGER, TAPE, TREMOLO, WAH, REVERB). Drag a chip UP into the chain to add it, drag a chain pedal by its label sideways to reorder, drag one DOWN out to remove; a scrollbar appears when the chain outgrows the screen. Each pedal has its real knob row (drag to dial) and footswitch (tap, or 1-9 by position). Below: a real six-string guitar (INSTR_GUITAR) - pick a chord on the ROOT (Z X C V B N M) + SHAPE (A S D F G) rows, then sweep the strings to strum (SPACE strums; M-row autoplay). Mouse and touch both work, every finger its own pointer. (Reverb is a send, so its chain position is cosmetic for now - the multiple-reverb-tanks step makes it a true insert.)

Pixel-Perfect Scaling

How do you scale thin pixel-art lines by a FRACTIONAL (float) factor without the lines wobbling/crawling as they move - and without blurring them to mush? This draws one world of thin 1px lines scaled the SAME way four times, side by side, each with a 7x MAGNIFIER below so the per-pixel structure is unmistakable: NEAREST (uneven pixel widths, hard edges crawl/shimmer as it scrolls), BILINEAR (no wobble but every edge is a wide soft ramp - blurry), SHARP (sharp-bilinear: each source pixel stays a FLAT colour, the blend confined to a 1-output-pixel seam at texel edges - crisp like nearest, stable like bilinear, single pass, the answer), and SHARP+g (same but the seam is blended in LINEAR LIGHT / gamma-correct, so a moving bright line keeps its true brightness instead of pulsing dark each sub-pixel step). Watch the magnifiers while it scrolls: nearest's bright core jumps 2px<->3px, bilinear fades over several blocks, sharp holds a flat core with one soft seam-block sliding smoothly. All CPU here via pset_rgb, reproducing exactly what a GPU blit does (which is one effectively-free shader pass), so the comparison is faithful with zero engine changes. See docs/design/pixel-perfect-scaling.md (this filter comparison) and docs/design/window-fill-scaling.md (the other, unbuilt half of the original idea: filling a resizable/web/fullscreen window fractionally instead of locking to the last integer scale step). Controls: LEFT/RIGHT arrows change the scale (0.05 steps), Z toggles auto-scroll (on by default - scrolling animates the wobble), X toggles a slow scale 'breathe'.

raymarch

A 3D scene that is JUST A MATH FUNCTION - the third chapter after shadelab (a pixel is a function of u,v) and caustics (warp where you look up a colour), and the worked showcase for the new shadermath.h GLSL-vocabulary header. There are no triangles, no mesh: the whole world is one function, scene(p), that returns how far the nearest surface is from any point (a SIGNED DISTANCE FIELD). Each pixel shoots a ray and marches it forward in steps of exactly that distance (it can never overshoot) until the distance drops to ~zero - a hit. The surface normal for lighting is just the gradient of that same function, sampled with four taps. scene() is six lines because shadermath.h supplies vec3 + dot/normalize/length, the sd_sphere/box/torus/plane primitives, and the op_smin smooth-minimum that BLENDS two surfaces into a gooey metaball merge - trivial with distance fields, painful with polygons. Three scenes show the vocabulary: melting metaballs (op_smin), a tumbling torus, and a box with a sphere carved out (op_sub); shaded with a sun + blinn specular, an Inigo-Quilez cosine palette() for colour, a checker ground and distance fog. Written so it reads almost exactly like the GLSL you'd find on Shadertoy. MOUSE orbits the camera, UP/DOWN zoom, 1/2/3 or LEFT/RIGHT switch scene, [ ] pixel size (raymarching is heavy - chunkier trades detail for speed), SPACE freezes time.

reverb spaces ⚡2×audio

The showcase for the reverb SEND-BUSES - two independent reverbs ringing at the same time, which the single shared reverb (cathedral) can't do. A bright MALLET sits in a small, tight, bright ROOM (tank 1) while a soft ORGAN blooms in a vast, dark, endless PLATE (tank 2): same note family, two completely different spaces, one mix. Built on reverb_bus(tank, size, damp) to carve each space on its own bus and instrument_reverb_bus(slot, tank, mix) to send a slot into it. The screen splits into the two rooms; each rings its own colour of light when struck (tight yellow rings on the left, slow indigo swells on the right). Drag ROOM / PLATE to resize each space live; press 1..4 to ring the room and 5..8 the plate; SPACE toggles AUTO (the two spaces trade phrases so you can just listen); H for help. Part of the effects-bus / pedalboard family.

rotated text (playground)

A throwaway sandbox for the experimental print_rot() — does the bitmap font hold up rotated? A fan of the same word radiates from one anchor at 30-degree steps (so you can see the pivot sits at the start of the text), one big word you drag through every angle live, and a column of fixed 0/45/90/135-degree samples for a crispness check (right angles stay pixel-crisp; odd angles go softly GPU-sampled). LEFT/RIGHT nudge the angle, SPACE toggles auto-spin.

seinelaan 31

A real Eindhoven apartment (Seinelaan 31) walked as a top-down level, built from its Floorplanner .fml by the fmltools pipeline. Walls with walkable doorways and real door/window sprites, each room a distinct floor colour, 72 furniture pieces as top-down pixel sprites baked from Floorplanner CDN renders. WASD/arrows move, T toggles sprites vs boxes. Sibling of floorwalker.

Sloppy text

Hand-lettered / ransom-note text: instead of one font drawn straight, each glyph picks from a couple of fonts and gets a small tilt + vertical nudge, so a plain string reads like it was scribbled or cut-and-pasted. Pure cart-land — just font() + print_rot() + text_width(), no engine changes. The wobble is deterministic per character (a hash of its index) so it sits still and looks deliberately wonky rather than flickering. Shows four intensities: a barely-there shaky-printer look, a wonkier hand-placed line, a slow live 'drunken sway', and a ransom note that mixes the big COMIC font in among the 8x8 ones, bottom-aligned so the baseline holds. Copy print_sloppy() into any cart that wants the effect.

upright bass ⚡2×audio

The jazz double bass, played the way you actually play one: the FINGERBOARD is the instrument. Four strings (E A D G), pitch running left-to-right. Press a string to sound a note, slide LEFT/RIGHT to WALK THE FRETS (each semitone re-articulates - clean in both directions, like fingering a walking line), PULL the string UP to BEND the pitch continuously (up to +2 semitones, the string visibly deflects toward your finger), lift to damp - monophonic and last-note-wins. You can also PICK: start a drag in the open space NEXT TO a string and sweep THROUGH it, and it plucks the moment your finger crosses it (each string sounds at the fret under your finger) - press right ON a string grabs/frets it, press in the gap picks it. The split is deliberate and matches the engine's physics: a waveguide string bends UP cleanly but can't be bent below its pitch (verified), so downward motion is the fret walk and the up-pull is the smooth continuous bend - horizontal picks the note, vertical is the expression. The right hand is an ARTICULATION switch, and pizz + arco are the SAME string model (INSTR_BOWED - the engine's built-in eng_tune pizzicato mode plucks the very string the bow would otherwise draw, exactly like the real instrument): PIZZ is the jazz sound, a woody finger pluck that rings and thumps (default); ARCO draws the bow - a slow speak, sings while held, with a left-hand vibrato; SLAP adds the string snapping back onto the fingerboard (the rockabilly thump). And the WOOD around the fingerboard is PERCUSSION - slap the belly (right) for a low boom, knock the neck (left) for a drier tick; where you hit maps the pitch but it keeps the woody bass-body character (INSTR_MEMBRANE + a knuckle transient). TONE sets mic/pickup darkness; RING is how long a pizz note rings after you lift. Range E1-G3. Play with mouse or a phone tap, or the computer keyboard (GarageBand musical-typing map, A = E1; Z / X shift the octave). Dressed as an upright laid sideways: scroll + tuning pegs at the left, ebony fingerboard with faint fret guides, bridge + f-holes at the body end, the low E string drawn thickest, and the live string deflecting as you bend it.

vowel

The FORMANT FILTER as the instrument - the showcase for formant(): four bandpasses parked at the human vowel frequencies, so a plain buzzing synth suddenly SAYS a vowel. A held saw-chord drone runs into the filter; sweep VOWEL and the chord talks OO->OH->AH->EH->EE. This is the single-input vowel filter (the talkbox family, played with a knob instead of your mouth) - NOT a vocoder, which needs a separate carrier x modulator input. The BUS side of the vowel story (colour ANY sound); INSTR_VOICE is the instrument side (a synth that sings on its own). Newest box in the effects family (spacecho/cathedral/juno/mistress/tapeloop/clavinet/eq/bitcrush/organ/vowel). The on-screen MOUTH morphs with the vowel and a ruler tracks OO..EE. VOWEL the talking knob (1..5 jump straight to a vowel), Q how pronounced/nasal, MIX dry..wet; AUTO [A] sweeps it on its own, BYPASS [Z] A/Bs the raw saw chord, H help.

bitcrush

Lo-fi quantization - the crunchy 8-bit / retro grit - shown master vs per-instrument. A clean PLUCK melody plays over a SAW bass through the new crush() bus: drop the BIT DEPTH (floor to 2^bits levels - low = gnarlier steppy quantization noise) and the SAMPLE RATE (sample-and-hold every Nth sample - the downsampled aliasing whine). Cycle the route MASTER (crush the whole mix) -> BASS ONLY (instrument_crush on just the bass, so the lead stays crystal while the low end goes lo-fi - the point of making it a per-instrument bus, not master-only) -> OFF, and watch the live quantization-staircase preview redraw as you turn the knobs. UP/DOWN sets bit depth, LEFT/RIGHT the sample rate, A (or tap the banner) cycles the route.

braindance fm ⚡2×audio

Aphex Twin's drill'n'bass / braindance, generated forever - Path B of the Aphex problem (he's a RANGE, not a genre, so this builds ONE mode: the chopped-break chaos with a sweet, slightly-wrong melody floating over it). Beauty over brutality: strip the melody and it's jungle, strip the chaos and it's a music box - the station IS the tension between the two layers. The brains, cart-side over radio.h's clock: RHYTHM AS GRAMMAR + a VOLATILITY knob (the kit is not a pattern - anchors persist, kick on 1, snare backbeat, everything else RE-ROLLS every bar on engine rnd; volatility 0 = a near-stable loop, 1 = never the same bar twice - so R replays the track but the drums shred anew); RATCHETS (a hit becomes 3-8 sub-hits at 1/32-1/64 with vol/pitch ramps - the impossible drill rolls, sample-exact); TWO CROSSED DENSITY CURVES (the serene melodic top and the violent drums ride INDEPENDENT curves - the Flim move - drawn as the red D and teal M bars in the window); THE LURCH (sudden DROP events strip to the pad, then SLAM back with a fill); and MISTUNING AS TIMBRE (every melodic voice detuned a few cents + a sub-Hz tape-wow pitch LFO - the machine alive and slightly broken). The sweet top is a Casio CZ PD sweep-pad (the evolving wowww) + a detuned glassy music-box (MALLET); the bottom is a synth break kit + sub + a 303 acid line. The chopped Amen is FAKED (we have no sampler - that granular/time-stretch want is logged). The vibe rolls sweet / drill / funk / eerie. The window is a glitchy oscilloscope that tears with the drums over the two density bars. SPACE next track, R replay (drums shred anew), [ ] history, LEFT/RIGHT density (calm/warm/hot/mental), UP/DOWN tempo, T tone, B band (kit amen/808, topline musicbox/glock, tape warped/clean), M power, H help.

clavinet ⚡2×audio

Hohner Clavinet D6 (1971) through an AUTO-WAH - the funk machine, and the showcase for wah(). A clavinet is a bright, short, percussive plucked-reed keyboard; run it into an envelope filter and you get the Superstition / Higher Ground talking wakka-wakka: the filter OPENS on each hard stab and quacks shut between them, following how hard you play. This is the realistic auto-wah, which (the scar) had to be a BUS effect - an envelope follower on the summed signal, not a per-note sweep, so it pumps with the groove. Sixth box in the effects family (spacecho=echo, cathedral=reverb, juno=chorus, mistress=flanger, tapeloop=tape, clavinet=auto-wah). A syncopated 16th C-minor funk riff plays itself; the WAH footswitch A/Bs the bare clav vs the talking wah; SENS sets how much your playing opens the filter, RES is the quack, MIX is dry..wet. The on-screen MOUTH opens with the wah (ooo->aah) - harder stabs, wider vowel. WAH footswitch [W], SENS/RES/MIX knobs, SPACE toggles the AUTO riff, 1..6 stab a note by hand, H help.

deeper platformer

An atmospheric descent that showcases the reverb + echo buses as SPACE, not as an effect knob. A procedurally-built vertical world of rooms and corridors that only ever goes down - wide halls, tight chambers, and the narrow shafts you drop through between them. You hop around (small hops: you descend, you don't climb) and your footsteps make little noises - and those noises REFLECT the room you're in: a boxed-in corridor gives a dry slappy tick, a great hall gives a long lush tail, and the reverb glides open as you walk from one into the other. The acoustic is driven live from room_openness(), a measure of the air around you, shown on a HUD meter (corridor/chamber/hall). Distance-lit stone walls and a lantern-glow follow you down; a slow drip rings out in the open halls to let the tail sing. Glowing motes scattered off the straight drop chime a reverberant mallet when grabbed, and the bottom of every section is a grand treasure hall - a hoard plus a SUPER TREASURE crystal that rings a drenched arpeggio - before the floor gives way into a fresh, deeper section. Move: arrows/WASD. Hop: Z or Up.

drivemodes

The four flavours of the drive() grit knob, side by side on one growling bass. instrument_drive_mode() picks the waveshaper - SOFT (tanh, warm tube overdrive), HARD (hard clip, buzzy digital fuzz), FOLD (sine wavefolder, metallic and glassy), ASYM (asymmetric tube, adds the fat even harmonics) - while instrument_drive() stays the amount. An auto-riff keeps the bass going so you hear the mode flip live, with a representative waveshape drawn under each panel. All four are a true bypass at drive 0 and hold full-scale loudness, so they change character not volume. LEFT/RIGHT (or tap a panel) picks the mode, UP/DOWN rides the drive amount, Z plucks.

engine tuner

An EAR test for EVERY pitched engine. Sweeps a chromatic scale very low to very high and sounds the selected voice TOGETHER with a pure SINE at the same pitch: in tune = the two lock and sit still, drifting = an audible beating/wobble that speeds up the further out it goes (the classic tune-against-a-reference trick; your ears are the meter, tools/tune-check.js is the headless number version). TAB cycles the whole library (the 5 PIPE presets, then reed/brass/pluck/bowed/guitar/piano/epiano/mallet/fm/pd/organ/voice + a raw saw that should lock dead). PIPE leads the list — its pitch emerges from a feedback loop so the macros retune it: in tune at a focused embouchure (morph >= 0.5), flat up high at a hollow one. SPACE pauses and HOLDS the current note so you can judge the beat; UP/DOWN ride the embouchure (PIPE) to hear it pull in and out of tune; R toggles the reference; keys 1-5 jump to the PIPE presets. Companion to docs/instrument-bank-plan.md.

mellotron ⚡2×audio

The 1963 tape-replay keyboard, faked in pure synthesis. A real Mellotron has NO oscillators - each key drags a strip of pre-recorded tape (a real strings/choir/flute/brass section) across a playback head. We have no sample playback (code-first synthesis, on purpose), so the cart reconstructs the CUES the ear uses to believe a recording: each VOICE is a drawn single-cycle wave (harmonics stacked via wave_set into INSTR_USER0, the tapeloop trick); every key-press makes a soft airy breath of noise as the tape-head engages and the note settles UP to pitch over ~90ms (the capstan spinning to speed - the real Mellotron onset, modelled with a pitch mod-envelope rather than a synthy click); chorus() turns one wave into an ENSEMBLE; a gentle vibrato + slow filter drift keep the timbre from freezing; then tape() (wow/flutter/saturation) and reverb() add the worn tape and the room. The headline is the signature Mellotron quirk: THE ~8-SECOND TAPE LIMIT - each key's tape is finite, so a held note runs out and stops on its own even with the key still down (lift and re-press to rewind). Each held key shows its tape draining from the top in the voice colour, then goes dark when it runs out. LAYERING - a real Mellotron tape frame holds three tracks, so you can blend them: tap the VOICE buttons (STRINGS / CHOIR / FLUTE / BRASS) to stack timbres into the loaded tape (the drawn single-cycle waves are summed - additive, still one voice per note), or hit a COMBI preset (STR+CH, STR+FL, CHO+FL, FULL). Dressed as an M400 cabinet: wooden end-cheeks, a cream control panel, a logo plate, the voice/combi selectors and TONE + TAPE (loop length 2-8s) knobs. Hold keys to play - computer keyboard uses the GarageBand musical-typing map (white keys on the home row A S D F G H J K L ; ' with A = C, black keys on the row above W E T Y U O P - all labelled on the keys; Z / X shift the octave), or mouse = one finger, or touch = chords up to ~5 fingers and slide for glissando.

napoleon radio ⚡2×audio

An ARTIST station for the musical world of Napoleon Dynamite (2004) - not one texture re-keyed, but the dial playing five recognizably DIFFERENT songs of theirs, the deliberate genre-clash that IS the film's soundtrack. Each SPACE rolls one of five SONG ARCHETYPES (stolen-playbook chord brain), and each fixes its own lead voice, groove, tempo and form; the seed only varies key/patterns within it. DANCE - Napoleon's class-president dance ('Canned Heat'): ~124bpm acid-funk, four-on-the-floor, popping slap bass + auto-wah clav 16ths, real horn-section stabs, falsetto 'ooh'. SERENADE - Kip's wedding song to LaFawnduh ('Always & Forever'): ~68bpm quiet-storm soul, a SUNG falsetto croon over lush Rhodes + string pad, finger-snaps. SWIHART - John Swihart's deadpan score (the film's actual identity): ~96bpm stiff straight-8s, a cheap detuned toy-organ melody doubled by muted pizzicato guitar + glockenspiel. FOREVER - anthemic 80s synth-pop ('Forever Young'): ~108bpm half-time, fat saw pad, bright arp, big gated snare. FRIENDS - gentle fingerpicked folk ('We're Going to Be Friends'): ~88bpm nylon arpeggios + a single sung voice. The first radio voice to SING on INSTR_VOICE (AIR voices the engine as a vocoder; this one croons). Play along on the jam ribbon (the song's scale, the chord tones lit) - its voice and behavior change per archetype. SPACE next, R replay, [ ] history, LEFT/RIGHT feel, UP/DOWN tempo, T tone, M power, H help.

respond

A cart-land prototype of a responsive-layout primitive set, before any of it touches the engine. Drag the yellow lower-right corner to resize a 'virtual screen' rectangle - everything inside it is positioned with four candidate layout functions (flex, fluid clamp/%, anchor+inset, aspect-ratio) so you can watch a real layout REFLOW live as the screen changes size: a top bar stays pinned and fluid-height, a notification badge stays anchored to the corner, a 16:9 viewport letterboxes itself to fit, and the button bar flips from a row to a stacked column when the width drops under a breakpoint (wide -> phone). The idea: prove the toolkit in cart-land against a fake screen first, then graduate it to a runtime/lay.h header that takes the real screen rect. Drag the corner to resize; no other controls.

shadelab

A CPU fragment shader, the dreamengine way: there is no GPU shader hook, so every pixel is just a little C function returning a 0xRRGGBB colour through pset_rgb() - full 24-bit colour, bypassing the 32-colour palette, painted on the CPU. Flip through ten worked shaders - uv coords (red=x, green=y), hue sweep, distance field, plasma, value-noise clouds, warped checker, interference, a cursor torch and cursor ripples, and finally FEEDBACK: the read-AND-write shader that reads the previous frame back with pget_rgb (the new true-colour read-back), dims it, and re-paints it rotated+zoomed, so the screen becomes its own memory - a glowing swirling tunnel you can paint into by holding the mouse. Each shader is a few readable lines that ARE the lesson. UP/DOWN changes the pixel size so you can watch the fragments turn chunky (and trade detail for speed); LEFT/RIGHT or keys 1..9 switch shader; SPACE freezes time. The companion to the pset_rgb / pget_rgb engine primitives.

tapeloop ⚡2×audio

Frippertronics (Fripp + Eno) meets the Mellotron - and the showcase for tape(). The SOURCE is a faked recording of a real instrument: STRINGS, CHOIR or FLUTE, each a drawn single-cycle wave (a stack of a few harmonics via wave_set into INSTR_USER0). It feeds a LONG echo loop, and the whole circulating wash runs through TAPE, so every pass returns warmer and more warped: wow (slow pitch drift) + flutter (fast warble) + saturation (warm soft-clip + HF rolloff). The tape degradation turns a clean synth into an aging recording - it is what makes a delay sound like a worn tape loop. Fifth box in the effects family (spacecho=echo, cathedral=reverb, juno=chorus, mistress=flanger, tapeloop=tape). Two reels spin and wobble with the flutter; the tape sags and sways with the wow; a LOOP meter shows the wash hanging on. TIMBRE cycles the loaded recording (T, or tap the button); WOW / FLUTTER / SAT drive tape(); FEEDBACK sets how long the loop survives (echo regeneration); SPACE toggles AUTO (a sparse phrase plays itself into the loop); 1..6 drop a note in by hand; H help.

wow & flutter

The tape() effect made physical: a soft-body jelly blob in a scene that is playing back on a worn tape, where the SAME wow/flutter/saturation values drive the picture AND the sound in lockstep - no screen shader, the wobble IS the verlet simulation. The tape WEARS DOWN as it plays (degradation creeps up on its own) so the longer it runs the woozier it gets: WOW (slow) sways the whole scene and drags the loop transport; FLUTTER (fast) shivers the jelly rim and stutters the timing; SATURATION blooms the palette warm, fattens the blobs, and drives the mix harder through the real tape() master insert. A Frippertronics-style pad+bell loop smears through the echo bus while the blobs throb on the beat; the character bumps are foley. Grain, scanlines and dropout bands thicken with the wear. Hit SPACE to REWIND & CLEAN - snap it fresh and watch/hear the decay begin again. Move the blob: arrows/WASD. Bounce: Z or Up. SPACE: rewind.

afrobeat fm ⚡2×audio

Endless Afrobeat, live from the Shrine - the Fela Kuti & Africa 70 / Tony Allen homage, and the station that finally reaches the engines no other one does. THREE radio firsts, all 'untapped shelf' engines: FIRST RADIO INSTR_GUITAR - the two interlocking rhythm guitars (a muted 'tenor' chuck panned left, a brighter rhythm guitar panned right; the Karplus-Strong-plus-body model, and the weave IS the Afrobeat signature); FIRST RADIO INSTR_BRASS - the trumpet of the horn section (only faked brass existed before); and the horn SECTION proper, INSTR_REED tenor sax plus that INSTR_BRASS trumpet voiced a third apart and panned wide to fake the ensemble spread. The brains, all cart-side over radio.h's clock: THE MODAL VAMP (no changes, one mode held - mixolydian I7 or dorian im, sometimes alternating to a second centre i-to-IV); EUCLIDEAN POLYRHYTHM (a gankogui bell timeline on euclid 7-in-16 and a cross-conga on euclid 5-in-16 riding against the straight kit - three cycles of different length, the West-African interlock); THE TONY ALLEN FEEL (a broken-funk kit, backbeat snare with scattered off-grid ghost notes plus a syncopated kick, all pure performance so R replays the song but never the same ghosts); and TERRACED FORM with THE BREAK - the intro layers the band in one part at a time, the BREAK section strips back to drums-and-bass before the horns rip back in. The sax solo is the shared improviser walking the mode. Seeded per song: the mode, key, vamp, bass ostinato, guitar interlock, horn riff, the GROOVE (laidback / driving / heavy halftime) and the FORM (cut / set / jam). The window is the Shrine stage, a saxophone in the sweeping lights. SPACE next song, R same tune (new solo), [ ] history, LEFT/RIGHT feel (cool/warm/hot/fire), UP/DOWN tempo, T tone, M power, B band (guitars/horns/comp - swap chairs live, horns can switch off), H help.

air fm ⚡2×audio

The Moon Safari station - the AIR (Nicolas Godin & J.B. Dunckel) homage, and an ARTIST station, not a genre: the dial plays recognizably DIFFERENT songs OF THEIRS, not one texture re-keyed. SPACE rolls a new tune and you get 'the Sexy Boy one' or 'the Cherry Blossom one' - a different song every time, but always THAT song. Built on the stolen-playbook chord brain: FIVE SONG ARCHETYPES, each a cited AIR track encoded as a template progression that ALSO fixes its groove, tempo, lead voice, mood and form. SEXY BOY (i-bVI-bVII vamp, a fuzzy driven Moog bass riff, laid-back four-on-floor); LA FEMME D'ARGENT (sunny dorian jazz loop, THE rolling melodic bassline, Rhodes comp, Moog lead); PLAYGROUND LOVE (a slow minor torch-song fall, smoky tenor sax, brushed kit); CHERRY BLOSSOM GIRL (bright I-V-vi-IV folk-pop, fingerpicked nylon guitar + breathy flute, airy); KELLY WATCH THE STARS (driving electro four-on-floor, a vocoder robotic lead). The seed varies key / melody cell / patterns / timbre WITHIN an archetype, so two Sexy Boys differ but both are unmistakably Sexy Boy. Reaches engines for AIR's real lineup: INSTR_VOICE as a melodic vocoder lead (a radio first), INSTR_PIPE breathy flute, INSTR_REED tenor sax, the Solina string-machine wash on a detuned-SAW pair, INSTR_EPIANO Rhodes/Wurli, INSTR_GUITAR nylon, and a fuzzy instrument_drive Moog bass - everything sitting in the echo bus's tape wash (AIR is always drenched). The window is a moon over the night highway. SPACE next song, R same tune (a fresh take), [ ] history, LEFT/RIGHT feel (hush/dusk/warm/aglow), UP/DOWN tempo, T tone, B band (strings/e-piano/echo), J jam strip (play along), M power, H help.

brass ⚡2×audio

INSTR_BRASS showcase - the lip-reed family (the tenth modeled ENGINE), and the LAST instrument the wavetables couldn't reach. An STK BrassInstrument waveguide: a bore delay line closed by a flaring bell, driven by a LIP VALVE modeled as a resonant biquad - the buzzing lips, whose resonance sits just above the played pitch (the mechanism behind lip-slurs and harmonic lock). It self-oscillates, so like REED and PIPE it HOLDS for as long as you blow. One id covers trumpet / cornet / flugelhorn / trombone / french horn / tuba. The three engine macros: instrument_harmonics = instrument/bore (0 = tight bright trumpet, walking up through cornet/flugel/trombone/horn to 1 = dark wide tuba - it drives the lip-resonance ratio, the lip Q, and the bell lowpass, never the pitch), instrument_timbre = BRASSINESS (0 = round and mellow; 1 = loud and blatty - the pressure-driven wave-steepening shockwave that makes a real horn open up at fortissimo, so the drive scales with blow pressure AND the macro: blow harder, get blattier), instrument_morph = breath/lip lean-in (0 = soft steady; 1 = a growling breath with deeper vibrato). THE SLIDE (the marquee): brass tracks pitch LIVE, so it slurs and glisses - grab the trombone SLIDE at the top and DRAG it for a continuous glissando (note_pitch + a tight note_glide, the finger IS the slide). Because it HOLDS, all three macros move live on a sounding note - sweep brassiness (SPACE auto-swell) and hear the tone bloom blatty. THE MUTE: closing the bell with a hand/plunger - a swept resonant lowpass on the voice (note_cutoff + note_res, the OUTPUT lane per decision 0017, not an engine macro); drag the MUTE slider open->closed for the pinched/nasal 'tight' sound, and sweep it live for the wah-wah (a plunger plate creeps over the bell in the viz). Plus a VIBRATO slider (note_lfo pitch wobble). Six HARDWARE PRESETS on the number row are the acceptance tests - if 1 trumpet / 2 cornet / 3 flugelhorn / 4 trombone / 5 french horn / 6 tuba don't each sound like themselves, the macro mapping is wrong. MONO + slide (key V, default - a horn is one voice): a new key legato-slides the voice, last-note priority; poly mode blows an independent voice per key. A S D F G H J K blow and hold, Z/X octave, 1..6 voices, drag the SLIDE for a glissando, V mono/poly, drag a slider (live, or LEFT/RIGHT + UP/DOWN), SPACE brassiness swell, M autoplay fanfare on/off. Multitouch: blow a pad per finger, drag the slide while a note drones. Design + STEP-0: instrument-engines.md §8.8.10.

cathedral ⚡2×audio

The showcase for THE reverb bus (the first effect on the new master FX section). A church organ in a vast stone hall: strike a chord and it BLOOMS - the dry attack is brief, but the reverb tail swells and hangs in the air for seconds, the way a chord rings under a vaulted ceiling. Echo repeats taps; reverb is a SPACE, and that difference is the whole point. Drag the three knobs: SIZE = chapel to endless cathedral (tail length), DAMP = bright stone to warm dark stone (tail tone), WET = how drenched the organ is. Tap a chord pad or press 1..6 to ring it into the hall; SPACE toggles AUTO, a slow self-playing processional; H for help. Each chord throws an expanding ring of light that rises through the arches and fades over the length of its own reverb tail. Built on instrument_reverb() sends into a reverb(size,damping) room - a port of navkits Schroeder reverberator.

drift ⚡2×audio

Three drummers, one pattern, ranked by clock — a timing diagnostic you can hear. The same 16th-note pulse plays three ways at once: TRUTH (center) uses schedule_hit() to book each note a few steps ahead with a sample-accurate delay, so the audio thread lands it exactly on the grid; TRIG (left) fires hit() the instant the beat index changes in update(), so it wobbles by a frame; FCNT (right) fires every N frames assuming 60fps, so it can't keep time and slides. When the clocks agree the three collapse into one tight centered hit; as timing slips they flam apart and spread across the stereo field, and a scrolling scope per voice plots each hit's error in ms. Tap GLITCH to stall a frame (a GC pause / scroll on the web) — TRUTH holds, the frame clocks stumble. Especially revealing on a phone. TAP the buttons (mute each voice / tempo / glitch); keys 1 2 3 mute, LEFT/RIGHT tempo, SPACE glitch. Companion to docs/design/audio-timing.md.

electric mistress ⚡2×audio

Electro-Harmonix Electric Mistress (1976) - the flanger pedal (Andy Summers, Gilmour, the chime on Walking on the Moon), and the showcase for flanger(). A flanger is a short swept delay with feedback whose moving comb-filter notches give the JET-PLANE whoosh and the metallic chime - and it only reads on a rich source, so you strum a GUITAR through it. Third box in the effects family (spacecho=echo, cathedral=reverb, juno=chorus, mistress=flanger). The FLANGER footswitch A/Bs the dry guitar vs the swept comb; RATE/DEPTH set the sweep, FEEDBACK is the jet/metallic intensity (low=gentle, high=screaming resonant comb), MIX is dry..wet. The hero is JET: one button fires a 2-second noise swell through a deep slow flange = the textbook jet passing overhead. The COMB window draws the notches sweeping. Tap a chord pad or press 1..4 to strum E/A/D/G; SPACE toggles AUTO (a self-strumming progression); F footswitch, J jet, H help.

Gnome Hide & Eek puzzle

A forest hidden-object game that IS the ui.h loupe showcase. Little gnomes (red hat, white beard) are tucked among the trees — you can see them, but they're 3-4px, far too small to tap on a phone. Drag the corner box to summon a 3x magnifier lens, sweep it over the forest, and tap a gnome INSIDE the lens to catch it (it throws its arms up - eek!). A tap only counts through the lens, so the magnifier isn't an aid here, it's the whole game. Catch all 6; R = new forest. The gnomes are cart-drawn game objects (not widgets), so it routes taps via ui_loupe_over/ui_loupe_map while the lens visual comes free from the zoom_rect engine primitive. See docs/design/loupe-notes.md.

juno-6 ⚡2×audio

Roland Juno-6 (1982) - the showcase for chorus(), the engines master BBD chorus. On paper a plain 6-voice poly synth (one saw + sub oscillator, one resonant lowpass) - sh101 with more voices. What makes it a JUNO is the bucket-brigade CHORUS: flip the famous OFF/I/II switch and the dry mono synth smears into a lush, wide, shimmering stereo wash (a centered mono chord literally fans out across the stereo field - the Junos two amps). Tap the CHORUS strip (or press C) to A/B it; the WIDTH meter opens as the chorus widens the signal. RATE/DEPTH/MIX ride the chorus live, CUTOFF/RES shape the resonant lowpass. Tap a chord pad or press 1..4 (Cmaj7/Am7/Fmaj7/G7); SPACE toggles AUTO, a slow self-playing progression; H help.

Loupe

Magnifier interaction for tiny touch targets on a phone. A mock 808 (two rows of 16 small step buttons + four knobs) that's brutal to hit on mobile. Drag the corner box and a fixed 3x rectangular lens appears above your finger showing whatever it's over, magnified; lift to park it. A SECOND finger reaches into the lens and edits the fat, easy version - the lens blocks touches underneath so the real tiny widgets stay safe. Grab a knob inside the lens and you can drag right out of it and keep turning (the grab already landed; knobs re-anchor at the lens edge so there's no jump - and inside the lens a full sweep needs 3x travel, so it doubles as fine-control). Tap empty space to dismiss, then poke the tiny widgets directly to feel the difference. Self-contained POC for a ui.h capability.

mariachi fm ⚡2×audio

Endless mariachi, live from the plaza - a charro ensemble on a Saturday night, and the FIRST RADIO STATION TO REACH INSTR_BOWED: the violin section is the real bowed-string waveguide (every fiddle on the dial before this was faked on saw, like tango's), two desks panned wide for the ensemble spread, with a portamento scoop INTO the note and vibrato. It's also the second station to reach real INSTR_BRASS - two trumpets voiced a third apart, bright and blatty, that ANSWER the violins call-and-response. The rhythm section (armonia) is three registers of one INSTR_GUITAR engine: a bright short-ringing VIHUELA chattering the manico, a mid GUITARRA, and the woody GUITARRON bass on its root-fifth boom. The brains, all cart-side over radio.h's clock: THE SESQUIALTERA - a 12-sixteenth bar read two ways at once, 6/8 (accents on 0,6) against 3/4 (accents on 0,4,8), with the guitarron anchoring one meter while the vihuela accents the other on hemiola bars - two against three, the son jalisciense's signature cross-rhythm; the GROOVE rolls son (the lilting sesquialtera), vals (a clean 3/4 waltz, no cross-rhythm) or huapango (fast, hard hemiola). FUNCTIONAL HARMONY - a major-or-minor key with a I-IV-V walk, a secondary dominant (V/V) and a FORCED V-to-I cadence, one 8-bar progression locked so every copla sings the same changes. THE COPLA + THE RESPUESTA - the violins state a diatonic melodic cell in parallel thirds (the verse), the trumpets answer it a section later (the figure echoed/inverted, also in thirds); they TRADE, never both on the melody at once. THE ADORNO - in the showy section a soloist (violin or trumpet, rolled) rips a scalar flourish, pure performance rnd so it is new every replay. FORM rolls corto / son / fiesta: an entrada fanfare, coplas, trumpet trades, the adorno, and a remate tag that actually ends the tune. Seeded per song: key, major/minor, the progression, groove, form, tempo, the cell and the trumpet figure. The window is the plaza at night - papel picado banners, a charro in the great sombrero, a trumpet bell flashing when the horns play. SPACE next song, R same tune (a new adorno), [ ] history, LEFT/RIGHT feel (suave/tibio/alegre/fiesta), UP/DOWN tempo, T tone, B band (violines seccion/solo/sinte - sinte swaps the bowed strings for smooth saw synth-strings; trompetas dos/una/off; armonia vihuela/nylon), M power, H help.

polo & pan radio ⚡2×audio

The Polo & Pan station - their escapist French dream-pop, and an ARTIST station, not a genre: SPACE rolls a new tune and you get 'the Canopee one' or 'the Tunnel one' - a different song every time, but always THAT song. Built on the stolen-playbook chord brain: FIVE SONG ARCHETYPES, each a real Polo & Pan track encoded as a template progression that ALSO fixes its groove, tempo, lead voice, mood and form. CANOPEE (sunny tropical pluck-house ~115bpm: a bouncing pizzicato+marimba riff, vocoder 'ah' accents, the famous stacked-mallet outro); ANI KUNI (driving Balearic chant-house ~122bpm: a hypnotic vocoder chant cell + a bright pluck-arp build, a big terraced drop and break); NANGA (dreamy downtempo exotica ~100bpm: a breathy flute over balafon + congas, a hypnotic wander, no drop); TUNNEL (dark propulsive minimal ~120bpm: the fat resonant Korg MS-10 synth-bass riff IS the song, sparse glassy stabs); COEUR CROISE (warm romantic dream-pop ~108bpm: a sung wordless lead over a lush Solina pad, glockenspiel twinkle, pizzicato comp). The seed varies key / progression / patterns / timbre WITHIN an archetype, so two Canopees differ but both are unmistakably Canopee. The lineup leans on the mallet-and-percussion + barely-used engines: a marimba/balafon/glock/vibe mallet chair, an INSTR_BOWED PIZZICATO bounce, a topline that swaps engine per song (INSTR_PIPE flute / INSTR_VOICE vocoder chant / SINE glass & sung), the Korg MS-10 resonant SAW bass, a Solina string pad, and a breezy Balearic kit (four-floor + clap + swish + congas). The window is a sunny terrace - a palm canopy, a sun over a lagoon, the sky tinting per archetype. SPACE next song, R same tune (a fresh take), [ ] history, LEFT/RIGHT feel (hush/breezy/sunny/aglow), UP/DOWN tempo, T tone, B band (A/B the Nanga flute: INSTR_PIPE model vs a clean in-tune SINE), J jam strip (play along on the pentatonic), M power, H help.

solina ⚡2×audio

The ARP/Eminent Solina String Ensemble (1974) - THE string machine, and the chorus() companion to JUNO-6: there the chorus widens a synth, HERE the chorus IS the instrument. Not a synth but a divide-down ORGAN - every key you hold sounds (fully polyphonic, paraphonic), each a stack of sawtooths tapped at different FOOTAGES. Six voice tabs you toggle: strings (blue) Contrabass 16', Cello 8', Viola 8', Violin 4', plus brass (orange) Trumpet 8', Horn 4'; enabled tabs all sound = the divide-down mix. Bare, those stacked saws are a buzzy organ - flip the ENSEMBLE switch (off/I/II, key E) and the triple BBD chorus smears them into the lush breathing string wash of every '70s record. Play the 2-octave keyboard by touch or QWERTY (Z..M lower, Q..U upper) - HOLD a key and it swells in (CRESCENDO) then rings out slowly on release (SUSTAIN); TONE rides the master brightness. SPACE toggles AUTO, a slow self-playing string progression (on at boot); TAB or / for help.

trackgen (kart racing) racing

A procedural kart/race-track generator you can drive. A SETUP PANEL picks a STYLE — Grand Prix, Technical, Circuit, Speedway, Rally, Classic, Figure-8 — and eight levers (size, width, corners, variety, twist, chicanes, straights, smooth) reshape it with a live preview, then DRIVE. The hull styles come from the classic procedural-racetrack recipe, not a wobbly circle: scatter random points, take their CONVEX HULL (a guaranteed non-crossing loop), push crowded points apart, DISPLACE each edge midpoint perpendicular to carve the in-and-out concavities, then RELAX any corner too sharp to drive (the drivability clamp). CHICANES inject quick S-bends, the longest edge is kept as a MAIN STRAIGHT, and CORNER VARIETY mixes hairpins with sweepers. CIRCUIT is a different beast — a random FOURIER LOOP (the centre line is a sum of sinusoid harmonics) that winds back through the interior like a real kart track and, with twist cranked, crosses itself many times. A cardinal spline runs through the result (Speedway uses a stadium oval; Figure-8 blends an ellipse toward a lemniscate so it crosses itself once). Offset the spline ±half-width along its normal and the ribbon, curbs, racing line and chequered start/finish all fall out. The car is the steer model (speed-scaled steering + grip/drift) in a world up to ~3 screens wide, with a LOOK-AHEAD camera that leads the car by its velocity. Leave the asphalt and you bog down (gentle) with a gravel rumble. Each track has a SEED. LEFT/RIGHT steer, UP gas, DOWN brake, X drift, Z new track, R restart, M back to the panel. RACE six AI rivals over three laps. Every car — you and the rivals — runs ONE shared physics step; the rivals just feed it a steer/throttle from a tiny follow-controller instead of the keys. That controller IS the whole brain: look a few samples ahead on the centre line, steer at that point, and brake for the bend it reads further ahead. The six personalities are not six code paths — they are rows in a parameter table (look-ahead, braking margin, speed cap, line offset, wobble, drift threshold, aggression, rubber-band): PRO hugs the racing line, HUNTER chases you down when near, DRIFT slides wide through corners, SUNDAY pootles under a low speed cap, ROOKIE wanders and spins off, RUBBER catches up when it falls behind. Light car-to-car avoidance keeps them overtaking instead of stacking; live standings sit on the right, and finishing shows the final order. The same brain ports straight to sloop's open world — only the line it follows changes (the track centre line here, road_at() out there). Cars also COLLIDE: overlapping bodies push apart and trade momentum along the contact normal, so you can shove a rival wide into a corner and get shoved back — a hard hit bleeds speed and kicks the camera with a clack. Contact is mass-weighted per personality: HUNTER leans in (heavy, barely budges and flings you), while SUNDAY and ROOKIE yield (light, get knocked away) — so a collision expresses character too. TWO MODES (toggle in the setup panel): RACE, and TRAFFIC — same track, not a race. In traffic the AI holds a lane, follows the car ahead at a safe time-gap (IDM-style car-following), lifts for corners, and OVERTAKES — pulling into a clear adjacent lane to pass a slower car, so a car blocked behind you (even a stopped you) goes around instead of stacking up. Lanes are emergent from lateral position, so you participate: sit in a lane and traffic follows and passes you. Traffic gets a crowd of cars tinted by SPEED (red=stopped, green=flowing) so jams show; a cycling TRAFFIC LIGHT whose red is a stop-line all lanes queue behind; and a small reaction lag so dense following turns unstable and PHANTOM JAMS — stop-and-go waves with no cause — emerge on the loop, exactly the famous ring-road experiment.

ui.h loupe

The magnifier loupe, now built into ui.h — free for any widget cart. A deliberately cramped synth panel (tiny 6px knobs, thin faders, a 16-step button row) with ONE line of loupe code: ui_loupe(1). Drag the corner box and a 3x lens floats above your finger, magnifying whatever ui.h widgets it covers; a second finger edits the fat versions inside, while the lens blocks touches to the real tiny widgets underneath. Grab a knob in the lens and drag out — it keeps turning with no jump (ui.h re-anchors the knob at the lens edge; inside the lens a full sweep needs 3x travel, so it doubles as fine-control). Tap empty space to dismiss. The integrated companion to the standalone loupe POC. See docs/design/loupe-notes.md.

vox4 ⚡2×audio

The PROPOSED voice API (INSTR_VOICE), made playable — the set the by-ear audition landed on: VOWEL (what's said, U→O→A→E→I) · SIZE (who says it — vocal-tract length / formant shift, giant→child) · EFFORT (how it's said — ONE clean soft/dark/relaxed → bright/pressed knob, led by tilt + glottal press with only light breath, NOT the old breathy-noise bundle) · NASAL (open → hummed/nasal — the one color the other three can't reach: the honk, the chant). The 4th-axis hunt was decided by ear: roughness and buzz didn't earn it (they overlap the vowel/brightness territory), but nasality did — it reaches the hummed/Tibetan-monk-chant character nothing else gets. Vibrato stays the universal note_lfo modulator (V); consonant articulation is the separate voice_consonant()/voice_coda() events (see voxpad). For the monk drone: low pitch + NASAL up + EFFORT soft + vowel oh/oo. Drag the 4 sliders · SPACE drone · Z/X pitch · V vibrato.

voxab ⚡2×audio

The A/B COMPARATOR for the formant VOICE engine (INSTR_VOICE). Where voxlab explores the space, this cart decides BY EAR whether a subtle lever earns its place — the listening voxlab can't do. Holds TWO full param states A and B; TAB snaps the LIVE sustained tone between them INSTANTLY, so the difference lives in the flip, not in slider-hunting. SOLO-SWEEP (W) auto-ramps the SELECTED param 0→1→0 with everything else frozen, so you hear ONLY that param. An optional auto-RETRIG (G) re-articulates the held tone so you also hear attacks. The preset A/B PAIRS load a base differing in ONE lever for a direct flip-test: BW (derived vs navkit measured bandwidths) · NASAL (formant-config morph vs anti-formant notch — the two nasality models) · BUZZ (full glottal pulse vs smooth sine) · CREAK (clean vs vocal fry) · REDUCE (full vowel vs schwa). These exercise the EXPERIMENTAL navkit completeness-audit levers (voice_param indices 10-16: buzz/jitter/shimmer/creak/anti-formant nasality/schwa-reduce/measured-BW). Click a param row or use [ ] to select; drag the bottom slider to edit it in the live slot; C copies live→other. SPACE play · TAB flip A/B · Z/X pitch.

voxpad ⚡2×audio

The PHONEME KEYBOARD for the formant VOICE engine (INSTR_VOICE) — where voxab A/B's the continuous levers, this cart is for HEARING the full articulation set: every vowel and every consonant, including the navkit table-completion phonemes the other voice carts never trigger. Click a VOWEL (all 10 table vowels — ae ah aw uh er are the new ones, reached via the experimental diphthong path vow2+glide). Click a CONSONANT to articulate it: a consonant is a timed event (voice_consonant onset / voice_coda), not a held knob, so a click says 'C + the current vowel' — 'fah', 'shoo', 'chee', 'ngah'. The 14 underlined consonants (ng r w y dh f v z zh th p t k ch) are the ones appended to complete navkit's table. HOLD a drone (SPACE) and consonant clicks re-articulate MID-NOTE (connected, like the say probe); with no drone each click is a one-shot syllable that rings out. V toggles CV (consonant opens the note) vs VC (it closes the note). SIZE and EFFORT sliders push it to giant/child tract and breathy→pressed. LOOP (L) auto-repeats the current syllable — say it, pause, re-say it, over and over (it 'sings' the phoneme), and you can change the vowel/consonant mid-loop. Still drives the engine through the experimental voice_param()/voice_consonant()/voice_coda() path. Click vowel + consonant to say it · SPACE drone · L loop · V mode · Z/X pitch · drag SIZE/EFFORT.

bowed ⚡2×audio

INSTR_BOWED showcase - the bowed string (violin / viola / cello), the last modeled string engine. A Smith/McIntyre stick-slip friction waveguide: a bow drags the string, the rosin grips then slips, and that friction drives a SELF-OSCILLATING loop - so unlike the plucked/struck strings it HOLDS while sustained and swells as you lean in. STEP-0 (tools/navkit-bowsweep.c) mapped the Schelleng wedge of stable bowing and the three macros are pinned inside it: instrument_harmonics = bow position (0 = sul ponticello, near the bridge, bright/edgy; 1 = sul tasto, over the fingerboard, soft), instrument_timbre = bow pressure (0 = light/clean singing leaning-sawtooth; 1 = heavy/scratchy surface sound - a real articulation, not a bug), instrument_morph = bow speed/swell (0 = gentle; 1 = digging in, louder and cleaner). THE FEEL: you don't press a string, you RUB it - drag back and forth and it speaks; the energy ACCUMULATES, so the longer/harder you rub the more it builds and digs in, and stopping lets the bow rest (silent). A quick TAP instead PLUCKS the string - pizzicato, which is the SAME bowed waveguide: a second INSTR_BOWED slot flagged eng_tune(slot,0,1) seeds the string with a pluck and switches the bow friction off, so the identical string and body ring down (arco and pizz differ only in how energy enters, exactly as on a real violin). Six presets: 1 violin / 2 viola / 3 cello / 4 ponticello / 5 tasto / 6 tremolo. Keyboard: HOLD A S D F G H J to bow, tap Q W E R T Y U to pluck; LEFT/RIGHT pick a knob + UP/DOWN turn, Z/X octave, M autoplay arco. Multitouch: rub a drone with one hand, pluck a melody with the other. Design + STEP-0: instrument-engines.md §8.5 step 9.

carlos radio ⚡2×audio

Switched-On Bach: Wendy Carlos's Moog playing generated two-voice counterpoint - station #18, and the first to prove CHORD BRAIN #7, TWO-VOICE SPECIES COUNTERPOINT. Every other station writes a chord progression first, then drapes melody over it; this inverts it - there is NO progression table. Two independent melodic lines are generated by Fux's species rules (~1725) and the harmony is just whatever the two lines SPELL: consonance required on the strong beats, dissonance only passing on weak beats approached by step, contrary/oblique motion preferred over similar, and NO parallel perfect 5ths or octaves (they fuse two voices into one). The only given harmony is THE GROUND BASS - a seeded chaconne loop (a repeating chord-root cycle, the vamp brain's classical ancestor) the lower voice walks and both voices land on at the cadence. THE FEEL KNOB IS THE TECHNIQUE: LEFT = strict canon (the upper voice is a literal canon of the lower, one bar behind, up an octave - pure imitation), RIGHT = free counterpoint (the upper line generated fresh by the rules), the middle mixing canon bars with free bars - the texture of a real two-part invention. Both voices are the fat Minimoog signal path on loan from moog.c (INSTR_SAW through a resonant lowpass with a per-note filter envelope - the 'wow' - and a little DRIVE), with a quiet sustained tonic pedal behind them. One seeded key lift mid-piece (Bach's tonal journey), and the piece ENDS on a real V-i cadence with the voices converging to the tonic. The window is the contrary-motion LATTICE - the two lines on a pitch grid scrolling left, so you watch one rise as the other falls and see the canon's upper line trace the lower's shape a bar later. SPACE next piece, R same piece, [ ] history, LEFT/RIGHT feel (canon/invent/loose/free), UP/DOWN tempo, T tone, M power, H help.

gamelan radio ⚡2×audio

Endless Indonesian gamelan - the Java / Bali homage, station #19, and the FIRST station to leave the equal-tempered grid: TUNING AS DATA. The seed rolls slendro (5 tones) or pelog (7) as a CENT table, then jitters every degree, because no two village gamelans are tuned alike - each song is played on slightly different bronze, named for its ensemble (Kyai Kanyut, Mendung...). It's realized as a BRONZE BANK: one INSTR_MALLET slot per scale degree, instrument_tune()'d once per song to that degree's microtonal residual - so because an octave is exactly 12 integer semitones, the whole pitched range plays through sample-tight schedule_hit() on integer midi while the slot detune bends each note off the 12-TET grid. The suling (bamboo flute, INSTR_REED) takes the other road: note_pitch() float, truly continuous, floating free of the pulse. COLOTOMIC TIME, a new TIME brain: form is nested gong cycles, not bar/phrase/section - the great gong (gong ageng) closes the gongan, kenong marks its quarters, kempul the points between, and the window's cycle ring rides round to the gong. KOTEKAN, a new MELODY brain: two voices (polos + sangsih) on complementary onset masks that sum to an unbroken 16th stream neither plays alone - built by dealing alternate sixteenths, so the interlock is disjoint-and-full by construction (trace-verified). OMBAK is the timbral identity: the great gong is struck as a detuned PAIR, two slots a few cents apart, beating against itself. And IRAMA is the feel knob - the gamelan inversion of 'more': turn it up and the core melody SLOWS while the elaboration thickens (Java end to Bali end). The band is all bronze (INSTR_MALLET), the gong pair, the kendang hand drums (INSTR_MEMBRANE), and the suling. SPACE next gamelan (a new village), R same gamelan (the suling is new), [ ] history, LEFT/RIGHT irama (lancar/tanggung/dadi/wiled), UP/DOWN tempo, T tone, M power, H help.

guitar ⚡2×audio

INSTR_GUITAR showcase + tuning rig - the bodied plucked string. A Karplus-Strong string like PLUCK, but run through a resonant BODY (four parallel formant bandpass filters), which is the box that bare PLUCK lacks; it decays on its own like a real string. One id covers acoustic / nylon / banjo / koto / harp / ukulele - and pizzicato. The three engine macros: instrument_harmonics = body (0 = open and bodyless, a harp; 1 = resonant bright box, a banjo - lerps the four body formants from a broad/low/quiet voicing to a sharp/high/loud one and opens the dry/wet mix), instrument_timbre = string brightness (0 = warm nylon; 1 = bright steel - the excitation lowpass), instrument_morph = mute (0 = long open ring; 1 = tight muted pizzicato stop - the per-sample feedback decay). Eight HARDWARE PRESETS on the number row are the acceptance tests - if 1 harp / 2 nylon / 3 steel / 4 banjo / 5 koto / 6 uke / 7 pizz / 8 oud don't each sound like themselves, the macro mapping is wrong. Strings are real objects: grab one and drag to BEND its pitch live (the fractional KS read tap bends a ringing string), press open space for a pick and sweep to STRUM. A S D F G H J K pluck, 1..8 preset, drag a slider (live, or LEFT/RIGHT pick a knob + UP/DOWN turn), SPACE strum, M autoplay on/off. Multitouch: bend two strings at once, strum with one hand while another holds a slider. Design + STEP-0/1: instrument-engines.md §8.8.9.

italo disco radio ⚡2×audio

Endless Italo disco - spaghetti disco, the lovelorn machine-pop of early-80s Italy (Gazebo, Den Harrow, Ryan Paris, the Moroder lineage). Citypop's machine cousin, but neon-at-midnight MINOR instead of sunlit major: dramatic, desperate, unashamedly cheesy. PURE RECOMBINATION (the parking-lot prediction: 0 new brains, dessert) - ymo's arp + house's pump + the citypop gear change + FM keys + new minor templates. THE SEQUENCER BASS is the spine: a relentless 16th-note synth bass that bounces octaves (root low, root high, forever - the Moroder pulse) with seeded chord-tone spice, a resonant lowpass + per-note cutoff env giving each note an analog-sequencer blip. Harmony is a stolen playbook of five dramatic minor formulas - i-bVI-bVII-V, the descending i-bVII-bVI-V, i-iv-bVI-V (the harmonic-minor V, the tear) - all with the borrowed dominant that makes Italo weep. FM BRASS STABS (INSTR_FM, bright integer ratio) punctuate the offbeats; EPIANO KEYS (INSTR_EPIANO, the 'FM keys') comp the bed; a PD soaring lead (INSTR_PD, glided, minor-pentatonic) owns the chorus. THE SIMMONS TOM FILL - the unmistakable descending electronic-tom roll into every chorus - is the genre's signature gesture, and THE TRUCK DRIVER'S GEAR CHANGE lifts the final chorus + outro up a semitone (of course). 808 kit + sidechain pump on loan from house.c / tr808.c. Seed on display (ITALO_SEED / R / [ ] history), LEFT/RIGHT feel, UP/DOWN tempo, T tone, M power, H help.

Menigte

DRIVE a car through a living town of 10,000 NPCs. The SCALE experiment: every person is always alive because 'having a life' is not 'running a simulation' - each one's position is a PURE FUNCTION of (identity, time-of-day): home, commute (along the road grid), work, commute home, sleep. No pathfinding, just a few compares and a lerp, so all 10k stay live every frame even off-screen. The expensive walk-anim is reserved for the visible few (zoom in and the dots become little walking figures). Watch the tide: morning ORANGE rush toward downtown, midday BLUE at work, evening GREEN back to the suburbs. Drive: UP/W gas, DOWN/S brake-reverse, LEFT-RIGHT / A-D steer; Z/X or wheel zoom; F free camera; ,/. clock speed; T +1h; SPACE re-roll town; H anchors. Companion to procplaces (the world) and sloop (the full car sim).

Oersoep arcade

The cell stage of Spore, in a drop of pond water ("oersoep" is Dutch for primordial soup). Swim a microbe toward the cursor and eat to earn DNA, then EVOLVE: at each DNA cap you find a mate and drop into a cell editor to bolt on a part - flagellum (speed), spike (rammers recoil), jaw (eat anything), poison sac - that changes how you play. The pond is a boid flock judged against YOUR size every frame: smaller cells flee and are food, bigger ones HUNT you and bite, and a bite drains health - so the cell that chased you at tier 1 is lunch at tier 3. Climb the food chain across four tiers, then crawl ashore. Unlike rollswarm you can be eaten. MOUSE/touch swims toward the pointer, Z chooses herbivore (X carnivore) on the title, in the editor Left/Right pick a part and Z confirms.

orbit space

A gravity sandbox - build a rocket, launch, and watch the dotted PREDICTED PATH curve into orbit (or, far more often, into the ground). One honest physics core: point-mass inverse-square gravity, with the SAME integrator running the live ship AND the prediction, so the dots never lie - they show exactly where you'd coast if you cut the engine now. Burn until the path closes into a loop that clears the surface and you're in orbit; apoapsis (peach) and periapsis (blue) are marked live. Hold Z to thrust (on the pad it only lifts if TWR > 1), LEFT/RIGHT steer, SPACE stages, R resets. Press 1/2/3 to swap rockets and feel each way to fail: FALCON flies a clean gravity turn, finless PENCIL cartwheels, underpowered BRICK never leaves the pad. Crashes scatter the rocket into its own parts. A Kerbal-Space-Program-in-miniature; MVP - the parts-bin builder is next.

pan ⚡2×audio

The STEREO showcase - three ways to place a sound in the left-right field, the engine's first stereo feature. A ball bounces left to right and a held pad note follows it across the field (note_pan = positional audio: map a sound to where its source is on screen). Tap A for a hard-LEFT pluck, B for a hard-RIGHT pluck (instrument_pan, set once per slot, -1 = hard left, +1 = hard right). A low drone at the bottom pans on its own, hands-off, via an LFO routed to LFO_PAN (instrument_lfo with dest LFO_PAN = auto-pan, the declarative rotary/tremolo-pan motion). Pan uses a linear law with center unchanged, so a centered sound is bit-for-bit the old mono mix - nothing moves until you actually pan. Headphones recommended. A = hard-left pluck, B = hard-right pluck; the ball and drone pan themselves.

piano ⚡2×audio

INSTR_PIANO showcase + tuning rig - the struck stiff string (StifKarp). A Karplus-Strong string PLUS a dispersion allpass chain that stretches the upper partials sharp - the inharmonic, slightly metallic shimmer your ear reads as a real piano (and as a dulcimer or clavichord) rather than a plain string - run through a grand-piano soundboard. Struck; rings down on its own, so give it a long hit(). One id covers grand / bright piano / harpsichord / dulcimer / clavichord / celesta. The three engine macros: instrument_harmonics = stiffness (0 = pure harmonic tone; 1 = stretched metallic shimmer - the dispersion depth and the number of active allpass stages), instrument_timbre = hammer (0 = soft felt, mellow; 1 = hard, bright plectrum strike - the excitation lowpass, grand to harpsichord), instrument_morph = pedal (0 = dry/damped staccato; 1 = long open sustain with the highs held, like leaning on the sustain pedal). Six HARDWARE PRESETS on the number row are the acceptance tests - if 1 grand / 2 bright / 3 harpsi / 4 dulcimer / 5 clavi / 6 celesta don't each sound like themselves, the macro mapping is wrong. A one-octave keyboard: white keys A S D F G H J K, black keys W E T Y U - play with the computer keys or click/tap. 1..6 preset, drag a slider (live, or LEFT/RIGHT pick a knob + UP/DOWN turn), SPACE chord, M autoplay on/off. Multitouch: hold a chord with one hand, drag a slider with another. Single-string v1 (double-string detune + prepared buzz deferred). Design + STEP-0/1: instrument-engines.md §8.8.9.

pipe ⚡2×audio

INSTR_PIPE showcase - the ninth modeled ENGINE: a blown flute. An STK jet-drive bore (an air jet strikes the labium edge and self-oscillates, recirculating through a bore delay), so like REED and ORGAN it HOLDS for as long as you blow. One id covers concert flute / recorder / pan pipe - breathy, airy, woody, the close cousin of the reed and built on the same machinery. The three engine macros: instrument_harmonics = overblow (0 = pure fundamental; 1 = the octave flageolet jump plus bright harmonics - the jet nonlinearity gain, the flautist's overblow, which navkit's presets leave unused), instrument_timbre = breath air (0 = pure tone; 1 = airy/breathy - a flute is mostly air, filtered turbulence resonated through the bore), instrument_morph = embouchure (0 = hollow/dark recorder; 1 = focused/bright concert flute - the lip-over-hole coupling plus jet length). Because it HOLDS, the macros are live expression: sweep overblow on a sustained note and it jumps to the octave the way a flautist overblows. Ships with breath turbulence, a humanized pitch-vibrato, and a tongued attack chiff from day one (the reed lesson). The flute on the left shows the air jet at the embouchure and the overblow register; the air meter rides the breath macro; the panel prints the exact instrument() call. MONO + SLIDE (key V): a flute is monophonic and you slide between notes - in mono mode one voice sounds and a new key glides the breath to it (note_pitch + note_glide, last-note priority, slides back when you release), with the 4th slider as cart-side SLIDE (portamento time). Poly mode (default) blows an independent voice per key. Five presets (1 flute, 2 recorder, 3 pan pipe, 4 piccolo, 5 breathy). A S D F G H J K blow and hold, Z/X octave, 1..5 voices, V mono/poly, drag a slider (live, or LEFT/RIGHT + UP/DOWN), SPACE auto-breath swell, M autoplay phrase on/off. Multitouch: poly blows a pad per finger; mono the last finger wins and slides.

Procedural Places

A testbed for procedural generation: one free-fly explorer that hosts PLUGGABLE generators. Ships with two structurally-opposite ones - ROADS & CITIES (a noise density field zones the world into city/town/rural/highway and a nested road lattice is promoted per zone; cities cluster on the noise peaks, organic not a bullseye) and TERRAIN (fbm elevation as colour bands: sea/beach/grass/forest/rock/snow). Same seed = byte-identical world every run (engine value noise, seeded via noise3's z-slice). Forest/dungeon/cave gens slot in as more headers. Arrows/WASD pan, Z/X (or wheel) zoom, R new seed, 1/2 switch generator, TAB field overlay.

say ⚡2×audio

A PROSODY probe for the formant voice (INSTR_VOICE). Where vox/voxlab settled the timbre axes (vowel/size/effort), this one probes the fourth kind of control the voice needs to SPEAK rather than drone: pitch + timing + stress shaped over a whole phrase — and it uses ONLY today's primitives, so it tells us BY EAR where the engine falls short before any new API. The trick: re-firing voice_consonant() on an ALREADY-HELD note re-articulates a consonant mid-note, turning the 'one syllable per note' voice into connected speech on a single held note. RANDOM builds language-like simlish from a mix of syllable shapes — V / CV / VC / CVC (codas wired through voice_coda()) plus the odd diphthong glide — not a monotonous da-da-da string. Pitch is driven every frame along a per-syllable shape (flat/rise/fall/peak) plus phrase-level declination, so the contour panel shows the spoken melody. STATE./QUEST?/EXCLAIM! set the intonation (statement falls · question rises · exclaim falls hard); click a syllable to give it a pitch ACCENT (emphasis = higher + longer); the character row (normal/robot/kid/giant/whisper) is the old terminal say() 'vary character' lever — bundles of size/breath/open-q/tilt + pitch offset + pitch-RANGE + rate (robot = zero range, no glide → monotone). Surfaces the real engine gaps: no creak/jitter, only 8 consonants, no schwa, no diphthong. SPACE=say · R=random simlish · 1/2/3=mode · Z/X=voice · L=loop · click the panel=emphasis · RANGE/RATE sliders · -/+ root pitch.

sloop sandbox

Build a vehicle from parts on a grid, then drive it across a procedural world - Cataclysm: DDA's vehicle system as the seed. The one honest core: the rig is NOT a sprite with stats, it's a GRID OF PARTS, and how it drives is COMPUTED from what you bolted on. Total mass, centre of mass and moment of inertia are all derived from the grid, then the whole thing is one 2-D rigid body: accel = engine_force / mass (heavy rig crawls), turn rate = steer_torque / I (big rig turns lazily), and an engine bolted off the centre-line makes its own yaw torque so an asymmetric build genuinely pulls. Tire grip bleeds away sideways velocity so it tracks its nose like a car, not an air-hockey puck - and the handbrake (hold SPACE) turns that same grip term DOWN so the tail breaks loose and you DRIFT, laying tire marks on the asphalt, then hooks back up on release. The world is COLLIDABLE: an infinite, deterministic, chunk-streamed city of roads, houses, scattered cones and PARKED CARS, all resolved by one number - the contact impulse J vs each object's strength. Run a cone over (it gives, scatters), crash a house (it holds - until a heavy rig at speed smashes through), and shunt a parked car: the car is a REAL rigid body with mass and inertia, so the same impulse knocks and spins it like a billiard ball of steel and glass while kicking back on your rig (a buggy bounces, an 18-wheeler bulldozes), then it slides and spins a long way before settling - only an extreme hit crumples one. Clip any of them off your centre-line and the off-centre impulse spins you. Hit TAB for the BUILD editor: place parts on the grid (frame/engine/wheel/caster/seat) and watch the centre-of-mass crosshair and the mass/top-speed/turn/understeer readouts move LIVE - then flip back and drive what you built. Caster wheels roll but barely grip sideways, so an all-caster rig slides and pivots like a pushed piano. Each rig runs a transmission (cycle G: 1-gear / automatic / manual with a real H-gate, and reverse is a GEAR not the brake) and an ENGINE KIND (cycle K in BUILD): electric (flat, snappy), gas (revvy mid-band), diesel (low-end grunt), steam (spool-up), nuclear (huge, flat) - each is just power + mass + a delivery curve, so they drive AND sound distinct with no special-casing in the drive loop. The engine kind also carries its GEARING, which is what unlocks the extremes: press 9 for a SUPERCAR (RACE V12, tall gears -> 300 km/h) and 0 for a TRUCK (TRACTOR, ultra-short gears -> ~45 km/h of grunt). Press 1-0 plus -,= to load twelve preset rigs as editable templates and FEEL the difference - balanced buggy, heavy hauler, twin-engine sprinter, loose jalopy, darty motorbike, FWD/RWD/4WD drivetrains, the 300 supercar, the 45 km/h tractor-truck, a long lumbering 18-wheeler SEMI and a SCHOOLBUS - all from the same core with zero per-rig tuning. Grip is PER-AXLE (the two-axle model): push too hard and the tyres let go - the front washes wide (understeer), the rear steps out (oversteer), power-on breaks the driven axle loose, and the handbrake cuts the REAR for a drift; stand on the brake at speed and you lock up with skid marks and a screech. TAB build/drive, click to place, Z/UP gas, X/DOWN brake, LEFT/RIGHT steer, SPACE handbrake-drift, Q/E or the H-gate to shift (down at a stop = reverse), I ignition, G transmission, K engine kind, 1-0/-/= templates, R reset. GET OUT OF THE CAR: stop and press F -- you step out of the seat cell as a one-tile person (the seat's occupant, same scale as the rig's parts), walk with arrows/WASD (Z jogs), and the same world pushes back on foot: buildings and parked cars block you, the camera eases in to 1:1, and the GROUND drives your pace - tarmac and the pavement strip beside it walk full speed, grass drags you to ~0.6x (the same road_at() surface seam that drives the rig's grip, so it works identically in the procedural grid and in real OSM Delft). Walk back to your seat and press F to drive again -- on a long rig that means walking to the cab, because entry is the SEAT cell, not 'the vehicle'. A rig with no seat can't be entered, the same rule that makes it drivable. AND WALK INTO A HOUSE: every house has one door on its street-facing wall (found by probing road_at() -- houses face the street because streets are where houses face; a small dark notch marks it while you're on foot). The door is a real hole in the wall: step through it and THAT house's roof lifts off, revealing a deterministic BSP floor plan -- rooms, interior doorways, furniture hugging the corners -- generated from the building's identity, so it's the same house every visit, and guaranteed walkable (the generator re-rolls any plan whose rooms aren't all reachable from the front door). Walls and furniture collide; the camera eases in to 2x while you're under the roof; walk out the door and the roof drops back. Works identically over the procedural grid and real OSM Delft footprints. DRIVE A REAL CITY: drag a .rvb road-data file (e.g. data/delft-centre.rvb, made by data-tools/roadview/osm-roads.js) onto the window to leave the procedural world and drive real OpenStreetMap streets — the road surface drives handling (grip drops the moment you slide off the tarmac) and the real building footprints are solid obstacles you crash into; O reveals the data folder. Same runtime data hooks as roadview; swap the file, drive a different city.

vox ⚡2×audio

The formant VOICE engine (INSTR_VOICE — navkit VoicForm port) on the THREE axes the voxlab probe landed on (VOWEL = U→O→A→E→I morph · SIZE = formant shift / vocal-tract length, giant→child · EFFORT = one macro of breath + glottal open-quotient + spectral tilt, breathy/dark/relaxed → pressed/bright/clean), with TWO ways to play. The SLIDERS + SPACE hold a sustained drone you tweak by hand. The JAM PAD is a scale-locked 2D strip (like the radio jam bar): drag across it to sing — X picks the note (major pentatonic, always in tune), Y is the second dimension = effort (up = louder/pressed), and every new note grabs a RANDOM consonant + vowel so dragging auto-scats ('ba-doo-la-see'). The SHAPE toggle (S) flips where the consonant goes: CV 'b·a' = a consonant ONSET (voice_consonant), the note starts on it ('bah'/'mah'); VC 'a·m' = a consonant CODA (voice_coda), the note closes on it ('ahh-m'/'oo-d') as it releases. Consonants are timed onsets/codas, vibrato is the external pitch LFO (V toggle) — neither is an axis. Still drives the engine through the experimental voice_param()/voice_consonant()/voice_coda() path pending the final wiring. Drag the JAM PAD to sing · SPACE = drone · Z/X shift the scale root · V vibrato · S syllable shape (CV/VC) · drag the three sliders for the base voice.

voxlab ⚡2×audio

The FAT prototype for the formant VOICE engine (INSTR_VOICE — a navkit VoicForm port: a glottal pulse through four vowel formants). A probe: it exposes all SEVEN raw voice params on sliders (vowel U→I morph · size/vocal-tract length · breath · glottal open-quotient · spectral tilt · vibrato depth · vibrato rate) so you can AUDITION by ear which three deserve to become the public harmonics/timbre/morph macros. The four 'layout' buttons (gen / mouth / creat / sing) load candidate 3-axis combos — press one, sweep the sliders it leans on, judge whether that combination feels expressive. Drives the engine through voice_param(handle, idx, value), an EXPERIMENTAL by-index poke that retires once the axes are chosen. SPACE plays a sustained note · Z/X drop/raise pitch · drag the sliders.

worldgen

A faithful C port of the procedural world from my old gtascii project (an ASCII GTA), rebuilt as an endless, deterministic top-down map you pan across. The recipe is gtascii's, line for line: a layered value-noise heightmap (three octaves summed 0.6 / 0.3 / 0.1) thresholded into a terrain colour ladder — deep water, shallows, beach, dunes, scrub, grass, forest, hills, rock, peaks; meandering RIVERS carved by a second squared-noise field; CITIES dropped on habitable lowland (black footprints with a street grid), and ROADS that connect nearby cities only where the land between them is passable. Where gtascii scanned one fixed grid, this hashes each map cell so the same world streams around the camera with no global pass — effectively infinite. A live legend shows which biome the centre sits on. This is the world sloop's build-a-vehicle rig will later drive across (docs/design/sloop.md → rung 3, biomes). Controls: arrows / WASD pan, Z / X zoom the terrain in / out about the centre (gtascii's scalein 1/16/128), SPACE jumps to a fresh region, R recentres.

addis radio ⚡2×audio

Endless ethio-jazz - the Mulatu Astatke / Swinging Addis homage (the 1969-74 Amha/Kaifa golden age, the Ethiopiques crate), station #17, and the FIRST station to leave the major/minor world: SCALES AS DATA. The seed rolls one of four Ethiopian qenit (modes) - tizita, bati, anchihoye, ambassel - pentatonics whose big intervals sound like nothing else on the dial, and EVERY melodic voice (the vibes head, the bass ostinato, both solos) is built by walking the same qenit table, so the MODE is the song's identity instead of a chord progression (improv.h's mode7 contract eats any scale). THE MODAL VAMP, chord-brain by drone: no ii-V changes, just a tonic pedal (and sometimes a second center, i to iv / i to bII) held for eight bars while a locked bass ostinato hypnotizes - one chord for eleven minutes. FIVE engines in one band: vibraphone lead = INSTR_MALLET, Wurlitzer/organ comp = INSTR_EPIANO/ORGAN, the horn line = INSTR_PD (synth-brass - the engine's nearest thing to a reedy horn, since there's no breath model - doubling the vibes head in unison and taking the second solo), upright/electric bass = INSTR_FM, and the congas / bongos / kebero are all INSTR_MEMBRANE (the struck-drumhead engine). The form is a jam: intro, head, vibes solo, head, horn solo, head, outro - and both solos are PURE PERFORMANCE via the shared improviser, so R replays the song but the vibes and horn never solo it the same way twice. The window is the coffee ceremony - the black jebena pot steaming on a low table at dusk. Seeded per song: the qenit, key, vamp pattern, head cell, bass ostinato, and the band's timbres. SPACE next song, R same tune (new solos), [ ] history, LEFT/RIGHT feel (alem/mellow/swing/fire), UP/DOWN tempo, T tone, M power, B band (vibes/keys/horn - swap chairs live, horn can switch off), H help.

coaster & slide

Draw a track with the mouse, then watch it run. Flip with M between COASTER - a closed loop where a coupled train circulates forever, fed by a chain-lift (hoist) up the back - and SLIDE - an open water flume where riders flow top-to-bottom, splash at the end, and ride again. Same gravity-along-the-tangent physics core for both. Drag in empty space to lay track, drag a point to reshape it; hold B/S/H/F while drawing to paint boost/slow/hoist zones (green/red/yellow) or flip points (pink) where carts swap to the other rail for corkscrews. Up/down lengthen the train. Support beams drop to the ground automatically. Opens on a ready-made loop. A port of an old LOVE2D toy.

motorik radio ⚡2×audio

Endless krautrock - the Neu! x Stereolab homage, station #16, and the first to prove THE PROCESS FORM: a radio with NO sections at all. The relentless motorik 4/4 (a live drummer quantized dead to the grid - kick on every quarter, understated backbeat, straight-8th hat, no fills ever) drives under a thin Farfisa drone (INSTR_ORGAN, the engine that unblocked this station) with maj7 chords PLANING on top (parallel voicings gliding over the drone - the only harmonic motion there is). A single progress value 0..1 runs the WHOLE song: every layer accumulates and then ebbs on its own seeded threshold, never on a bar boundary - so the loop has no seam, which makes it the best game-background music on the dial (nothing ever interrupts). THE MODULATION EVENT: one seeded key lift per song, around two-thirds through, slides the whole drone up under the topline - a story beat, not a grid position. The least performance-random station on the dial; the invariance IS the genre. Seeded per song: key, mode (lydian/major/mixolydian), length, the layer thresholds, the modulation, the pad's planing path, the topline cell, and the band roll (bright Farfisa night vs dark Vox night, round-saw vs buzzy-square Moog bass). The window is an autobahn at night - centerline dashes streaming toward you at the pulse, each layer that enters lighting the scene a little further; the horizon flares when the key lifts. SPACE next drive, R same drive, [ ] history, LEFT/RIGHT feel (idle/cruise/drive/redline - pulls the layers in sooner), UP/DOWN tempo, T tone, M power, H help.

mouth harp ⚡2×audio

A jaw harp (Jew's harp / mondharp) — the instrument where the PITCH NEVER CHANGES and you play with your MOUTH instead. A buzzy fixed-pitch saw drone (every harmonic) runs through a TIGHT resonant BANDPASS (FILTER_BAND, resonance 14), and sweeping note_cutoff is your mouth cavity: the resonant peak hunts across the drone's overtones and picks out which one 'speaks' — the vocal boi-oi-oing / wah-yeoww talking quality, and THAT is the melody. The corner of the engine no other cart centres on: where otamatone moves pitch over a plain lowpass, here pitch is frozen and the high-Q formant sweep is the whole tune. Move the mouse up/down to play (a harmonic comb on the right glows on the overtone you're voicing). TAB switches two flavours: PLUCK (folk) — each twang decays, HOLD to auto-pluck locked to the tempo for the iconic boing-boing-a-boing, UP/DOWN sets the subdivision; DRONE (dan-moi) — one continuous buzz you shape forever, hold SPACE for a breath swell. SPACE or click = pluck, LEFT/RIGHT pick the harp's key, M autoplay.

pd ⚡2×audio

INSTR_PD showcase - the sixth modeled ENGINE: phase distortion, the Casio CZ sound. A cosine read through a WARPED phase ramp makes bright, buzzy, resonant tones with no filter at all (the warp IS the brightness) - rubbery basses, glassy resonant leads, and the famous CZ 'wowww' sweep. The three engine macros: instrument_harmonics = wavetype (snapped across 8 - saw / square / pulse / double-pulse / sawpulse, then 3 resonant types), instrument_timbre = distortion amount (brightness, or how high the resonant peak sits), instrument_morph = the DCW sweep (0 = static; turn it up and the distortion snaps bright on the strike then settles - the CZ envelope, which the navkit reference omits, so this is built from scratch). Like FM, the engine doesn't bake its amp envelope, so a CZ patch is macros plus an ADSR - both are sliders here. The scope draws the actual warped waveform; with the DCW sweep up it shows TWO traces - the bright strike (faint) settling to the steady tone. Five presets (1 cz bass, 2 reso lead, 3 synth brass, 4 sweep pad, 5 cz pluck), and the panel prints the exact instrument() call to copy into your cart. A S D F G H J K play a major scale, Z/X octave, 1..5 presets, drag any slider (or LEFT/RIGHT + UP/DOWN), SPACE chord, M autoplay on/off.

reed ⚡2×audio

INSTR_REED showcase - the eighth modeled ENGINE, and the first SELF-OSCILLATING one: a blown single/double-reed instrument. A bore delay line plus a pressure-driven reed valve that sings for as long as you blow, so unlike the struck engines (pluck/mallet/membrane) it HOLDS, like ORGAN. One id covers clarinet / soprano-alto-tenor sax / oboe - the blown family the wavetables can't reach. The three engine macros: instrument_harmonics = bore shape (0 = cylindrical clarinet, hollow and odd-harmonics-only; 1 = conical sax, full and bright - it drives the bell filter, the end reflection, and the conical even-harmonic buzz, with makeup gain since the conical bell is ~10dB quieter), instrument_timbre = reed edge (0 = soft and dark; 1 = stiff and nasal - stiffness paired with aperture narrowing plus an output brightness tilt, because stiffness alone is too weak in the model), instrument_morph = breath (0 = soft steady tone; 1 = a leaning, growling breath with deeper vibrato, held inside the pressure window where the reed self-oscillates - push a real reed past it and it chokes). Because it HOLDS, the macros are live expression: press and HOLD a key to blow and sweep breath for a swell no struck engine can make - all three macros move live on a sounding note. The bore on the left morphs cylinder to cone with harmonics, with airflow pulses and a breath meter; the panel prints the exact instrument() call. MONO + SLIDE (key V): a real reed is monophonic and you slide between notes instead of retriggering - in mono mode one voice sounds and a new key glides the breath to it (note_pitch + note_glide, last-note priority, slides back when you release), with the 4th slider as cart-side SLIDE (portamento time). Poly mode (default) blows an independent voice per key. Five presets (1 clarinet, 2 sop sax, 3 alto sax, 4 tenor sax, 5 oboe; harmonica's free reed sits below the self-oscillation floor, so it's out of scope). A S D F G H J K blow and hold, Z/X octave, 1..5 voices, V mono/poly, drag a slider (live, or LEFT/RIGHT + UP/DOWN), SPACE auto-breath swell, M autoplay phrase on/off. Multitouch: poly blows a pad per finger; mono the last finger wins and slides.

tabla ⚡2×audio

INSTR_MEMBRANE showcase - the seventh modeled ENGINE: a struck drumhead. Six decaying sine modes at a circular membrane's vibration ratios plus a slap contact click, buffer-free. One id covers tabla / conga / bongo / djembe / tom - hand percussion the analog 808/909 recipes structurally can't reach, because it's REAL membrane modes plus a pitch bend, not one sine plus a pitch envelope. The three engine macros: instrument_harmonics = head character (0 = tuned harmonic tabla, pitched and longer-ringing; 1 = inharmonic djembe/conga thud), instrument_timbre = strike position (0 = center thump; 1 = edge ring plus slap click - open/slap/mute in one knob, navkit's live circular-membrane weighting), instrument_morph = pitch bend (0 = flat; up = the membrane chirp / tabla bayan gliss - pitch starts raised off the strike and settles, bending all six modes together). A struck engine self-decays, so it has no ADSR (unlike fm/pd, which hold); the cart's fourth slider is instead a cart-side RING control (mute to open) - the hit() gate length, a tight palm-damped thwack to a stroke left to ring out, which is how hand percussion is actually played. The drumhead on the left shows the syahi tuning patch on the tabla side, a marker for where timbre strikes (center to edge), and ripples on every hit; the panel prints the exact instrument() call to copy into your cart. Five presets (1 tabla, 2 conga, 3 bongo, 4 djembe, 5 tom). A S D F G H J K strike a tuned low ladder, Z/X tune, 1..5 kits, drag a slider (or LEFT/RIGHT + UP/DOWN), SPACE roll, M autoplay groove on/off. Multitouch: drum with several fingers, sweep the pads for a roll.

epiano ⚡2×audio

INSTR_EPIANO showcase - the electromechanical keyboards, rooted in the originals: pick the MACHINE (1 RHODES / 2 WURLI / 3 CLAV - each its own colour), then flip ITS authentic stompboxes. Every key sums 12 decaying inharmonic sine modes through a PICKUP NONLINEARITY - the bark/buzz/honk that makes it electric, not a dull bell. Each machine carries the modulation that actually defines it, as self-contained pedals (footswitch + its own knobs): RHODES - VIBE (Suitcase stereo vibrato), DYNO (bright sheen), PHASE (the 70s swirl, RATE+STR); WURLI - TREM (the built-in tremolo), BUZZ (reed dig-in growl); CLAV - WAH (the Superstition funk), MUTE (the D6 damper). A BARK knob on every machine drives the pickup hard (read live on ringing notes). A small per-machine PRESET column (stage/suitcase/dyno, wurli/buzz, clav/mute) flips the pedals for you. White A S D F G H J K, black W E T Y U; SLIDE across the keys for glissando; Z/X octave; M autoplay. The DX/digital EP is the fm cart; this is the electromechanical one. Multitouch.

flappy arcade

The smallest *complete* game, start to finish: an animated attract/title screen, the play loop, a death sequence, and a game-over panel with a medal + a hi-score that survives restarts. ONE BUTTON on every device - SPACE / Z / gamepad-A / mouse-click / screen-tap all flap, so it's fully playable on a phone with no on-screen controls. The bird is drawn in code (sprite-draw.js): one bird() function sampled at three wing heights makes the flap cycle, plus a dead frame, soft clouds, and grass bushes. Juice on every beat: flap stretches the bird upward + puffs feathers + tilts its nose up; falling tilts it into a dive (sspr_ex rotate + squash); passing a pipe pops the score bigger with an ascending ding; crashing flashes the screen white, shakes, hit-stops, then tumbles the bird off spinning. Parallax clouds + scrolling ground. The capstone the tutorials were missing - the bridge from learning primitives to a finished game. Tap / Space / click to play.

handpan ⚡2×audio

A steel hang drum: one ding, eight tone fields, every strike a gesture. The mallet cart is INSTR_MALLET's tuning rig - this is the same engine as an INSTRUMENT, no knobs at all. Real handpans zigzag the scale across the circle (ascending notes alternate right/left climbing to 12 o'clock) so physical neighbors are consonant: two-handed noodling always sounds composed. WHERE you hit matters - the strike's offset from a field's center drives the timbre macro per hit (center = soft palm thump, edge = bright ping), and taps on the bare steel between fields are the shoulder tok. Four tunings to pick from the rack: kurd, celtic, hijaz, pygmy. Multitouch: every finger is its own pointer - both hands play, like the real thing. Tap/click fields (offset = tone), drag = roll, SPACE ding, A S D F G H J K ring notes ascending, 1..4 pick a pan, M autoplay.

mt-70 ⚡2×audio

A 1982 Casiotone home keyboard rebuilt with ZERO new engine code - the probe cart that proves 'two oscillators' is a recipe, not missing infrastructure. The real MT-70 mixed 2 (sometimes 3) sine waves per key, each with its own decay; here every key press fires 1-3 stacked notes on separate instrument slots, pitch-corrected to EXACT harmonic ratios with note_pitch floats (ratio 3.0 = +19.02 semitones - integer rounding would beat). All ten hardware presets transcribed from the source data, each with its original description ('the dullest piano ever'). The SRC switch is the A/B experiment: struck presets (vibes, chime, bells, celesta, banjo) can swap to a single INSTR_MALLET voice - your ear judges recipe vs engine. The voices meter shows the real cost: stacking pays 2-3 voices per key. Struck presets ring out past the lift (a true exponential decay driven through live note_vol - the linear amp ADSR can't bell); sustained ones gate off. Touch the keys (multitouch, slide = glissando), computer keys = GarageBand musical typing like moog (A S D F... whites, W E T Y... blacks, 1.5 octaves), 1..0 presets, Z vibrato, X src 2-osc/mallet, SPACE the obligatory demo tune.

organ ⚡2×audio

INSTR_ORGAN showcase - the fourth modeled ENGINE: every key sums nine drawbar sines at the Hammond footages, so what you hear is a registration (a recipe of harmonics), not one wave. Unlike pluck/mallet it is HELD - hold a key and it sustains, so the macros morph the tone LIVE while you lean on a chord. The same three macros every engine answers: instrument_harmonics = registration (snapped drawbar recipes, thin reggae to full gospel); instrument_timbre = brightness tilt + key click; instrument_morph = animation (0 still combo organ, up = scanner chorus shimmer + percussion chip). Eight presets (1 reggae, 2 combo, 3 bookerT, 4 jimmy, 5 larry, 6 ballad, 7 jonlord, 8 gospel) are baked knob positions. THE LESLIE is not in the engine - it is a per-voice recipe (tremolo + doppler LFOs, rate lerping slow/fast = the spin-up inertia); press L to hear it. A S D F G H J K hold keys (chords welcome), Z/X octave, 1..8 presets, drag a slider (morphs held notes live) or LEFT/RIGHT + UP/DOWN, L leslie, M autoplay. Multitouch.

ui kit

The ui.h showcase + device probe: button, slider, knob driven by mouse, touch, AND keyboard at once. Knobs play a sound (BLIP fires it, LOOP repeats on the beat), sliders drive the ball pit, so every widget audibly/visibly does something. Every finger is its own pointer - ride PIT and CUT with two fingers at the same time (the per-contact capture table at work). Mouse hover highlights, wheel fine-tunes a hovered knob. Press FOCUS (or F) for pointer-less play: arrows move the marching ring, LEFT/RIGHT adjust the focused value, Z presses a focused button.

what is code?

The very first lesson, before variables or loops: a program is a LIST of instructions the computer runs top to bottom, doing exactly what each one says. The code sits on the left, 'the screen' on the right - press NEXT (or SPACE) to run ONE line at a time and watch its mark appear. Eight lines of real studio.h calls (cls, rectfill, circfill, trifill, rect, print) build a little house, one step at a time, so you SEE the 1:1 mapping: this line -> this mark, in order, accumulating. The done lines get a green check, the current line a yellow arrow, and each shows its plain-English meaning ('a triangle - the roof'). Runs in a roomy 480x300 canvas so the code is readable at full size. Fully playable by button-tap or keyboard. R / OVER starts over and watches it build again.

city pop radio ⚡2×audio

Endless Japanese pop-funk - the city pop homage (Tatsuro Yamashita / Mariya Takeuchi / Plastic Love), sixth of the radio family. The canon as data: the ROYAL ROAD progression (IVmaj7-V7-iiim7-vim9, THE J-pop changes), Just-the-Two-of-Us loops (IVmaj7-III7alt-vim9-I9), the bittersweet descent (Imaj9-I9-IVmaj7-ivm6); octave-popping disco bass with double-chromatic 16th runs; two-voice guitar chucks that lay out for the bar turn; saw-brass anticipation hits; session-tight timing (the opposite of low end radio - no groove lag, +-2ms only); and the truck driver's gear change: the last chorus modulates up a whole step. Density = arrangement curve x feel knob; T cycles tone. Seed on display (CITYPOP_SEED / R / [ ] history), H help. Worked example #6 for docs/guides/game-music.md.

cocktail radio ⚡2×audio

An endless piano-trio set - the Vince Guaraldi / Oscar Peterson lounge homage, station #14. Two blocks make it: THE WALKING BASS, the long-promised ~20-line generator (chord tone on beat 1, scale/arpeggio motion through the middle, a chromatic approach into the next bar's root on beat 4 - four quarters a bar, forever, never repeating), and THE IMPROVISER's second gig - runtime/improv.h, extracted from roadhouse.c by the second-customer rule: the piano solos over full tension arcs, and then THE BASS TAKES A SOLO (same brain, low register, two-thirds density, the room leans in - brushes drop to a whisper, the piano just nods). Harmony is a weighted ii-V-I functional walk with secondary dominants and the tritone sub, cadences FORCED into the last two bars of every 8 - the set always comes home. Swing at 62%: ride pattern ding ding-ga-ding, hat snapping 2 and 4, feathered kick, brush sweeps. Trio set form: head, piano solo, bass solo, piano trades back, head out. R replays the tune - the solos are always new. SPACE next tune, [ ] history, LEFT/RIGHT feel (last call/set one/set two/burner), UP/DOWN tempo, T tone, M power, B band (swap chairs live), H help.

cr-78 compurhythm ⚡2×audio

All 15 voices of the Roland CR-78 (1978) rebuilt from their analog circuits with the synth API: damped-sine membranes (kick/bongos/congas), one noise source shaped per voice by different filters (the famous swishy bandpassed hats, highpassed maracas, resonant tambourine jingle), detuned square pairs/triples for cowbell and the metallic beat, and the guiro's ratcheting scrape — bandpassed noise chopped by a 36Hz volume LFO under a rising cutoff sweep. Plays eight classic presets including Disco-2 (In the Air Tonight), the Mambo+Beguine blend (Heart of Glass), and the triplet-feel Shuffle and Swing — plus the knob the original never got: Z/X sets swing 50-66% by scheduling the offbeat 8ths late (adjustable swing didn't exist until the LM-1 in 1980). The grid is editable: click/drag cells to toggle, click the orange strip to move accents, click a label to audition; accent steps are a volume boost, just like the real knob. Q-G play voices by hand, LEFT/RIGHT preset, UP/DOWN tempo, SPACE start/stop.

dub radio ⚡2×audio

Endless roots dub - the King Tubby / Augustus Pablo homage, seventh of the radio family, and the one where the engine IS the genre. ECHO AS SCHEDULED NOTES: every skank chop, rim shot and melodica phrase schedules its own decaying repeats (dotted-8th apart) - no FX engine, the delay line is just more notes in the future. THE DESK IS THE INSTRUMENT: every 4-bar phrase a performance-level mixing brain re-rolls which layers are in (bass ~92%, drums ~90%, skank, organ bubble, melodica); when the skank leaves, its ghost gets thrown into a long echo tail. The desk is engine-rnd, so the same seed MIXES ITSELF DIFFERENTLY every listen - exactly how dubplates worked. Seeded 2-bar minor-pentatonic riddim bassline, one-drop/rockers/steppers kits, dub siren at meltdown feel. Seed on display (DUB_SEED / R / [ ] history), T tone, H help. Worked example #7 for docs/guides/game-music.md.

exotica radio ⚡2×audio

Endless exotica - the Martin Denny / Les Baxter / Arthur Lyman homage: lush vibraphone over lazy latin percussion, faux-tropical lounge from 1957 (Hosono's origin story). The eleventh radio station, with three firsts: born on the runtime/radio.h scaffold instead of a hand-copy; ALL THREE modeled engines in one band (vibraphone lead = INSTR_MALLET with the motor on, nylon rhythm guitar = INSTR_PLUCK, glass-bell sparkles = INSTR_FM); and THE AVIARY - bird calls and frog croaks as an aleatoric performance channel, chance() per bar firing pitch-swooped calls that are never seeded, so replaying a seed replays the tune but the jungle never answers the same way twice (a bird crosses the lagoon window when it sings). Seeded per song: key, lounge changes (borrowed-iv dusk, pagan minor), the vibes cell with tremolo rolls, and the whole BAND's timbre (vibes macros, guitar pick, kit dressing, bird species). SPACE next song, R same tune (new birds), [ ] history, LEFT/RIGHT feel (lull/lounge/luau/rite), UP/DOWN tempo, T tone, M power, B band (swap chairs live), H help.

fm ⚡2×audio

INSTR_FM showcase - the third modeled ENGINE: two-operator FM, the DX-synth recipe. An inaudible modulator sine bends the carrier's phase; brightness DECAYS within each note like a real DX strike (bright attack, mellow tail), and SWELLS along a slow amp attack so brass can speak. The 1:1 detent carries the built-in DX tine - the E.PIANO attack ping. The three engine macros: instrument_harmonics = carrier:mod ratio (snapped detents - integers sound musical/harmonic, off-integers are bells and metal), instrument_timbre = brightness (FM amount), instrument_morph = modulator feedback (clean to saw-edge growl to noisy clang). Five presets (1 epiano, 2 bell, 3 bass, 4 brass, 5 clang) are knob positions plus an ADSR - a DX patch is both, since this engine deliberately doesn't bake its amp envelope. The modeling rig: seven sliders (three macros + a full ADSR with live ms readouts and a drawn envelope shape - the selected segment lights up), and the panel prints the exact instrument() call to copy into your cart. The scope draws the engine's actual formula live - strike a key and watch the wave mellow (and the tine flicker). A S D F G H J K play a major scale, 1..5 presets, drag any slider (or LEFT/RIGHT + UP/DOWN), SPACE chord, M autoplay on/off.

font bake

Title text baked from a real TTF (Google Font "Bungee") at BUILD time — no font code in the cart at all. tools/font-bake.js parses the TTF with a vendored opentype.js, flattens the glyph outlines and scanline-fills them (3x3 supersampled, optional darker AA edge) straight into sprite-draw canvases; fontbake.cart.js centers each word into a fixed slot-rect so the C side just sspr()s two sheet regions. The title sine-waves in 4px strips at 2x, and because baked text is ordinary pixels, pal() recolors it live. Drop any Google Fonts TTF into tools/fonts/ and bake your own. Z cycles the title color.

high noon arcade

A quick-draw reaction duel at sunset. Five outlaws, each with a faster trigger finger (SLOW JOE 600ms down to DEATH HIMSELF 215ms) — wait through the standoff, ignore the tumbleweed, and fire the frame you see DRAW!. Shoot early and the EARLY! verdict shames you; hesitate and you're DEAD. Every big word is a sprite baked from the Google Font "Smokum" (the wanted-poster slab serif) by tools/font-bake.js — the second font-bake cart, and the one where the words ARE the game: start signal and verdicts all sspr()'d sheet regions over a vgradient sunset. Z to draw.

house radio ⚡2×audio

Endless French house / filter disco - the Daft Punk / Stardust homage, tenth of the radio family, and the genre that made one trick a movement: THE FILTER RIDE IS THE SONG. note_cutoff()/note_res() swept live on held string-machine voices from an arrangement-level cutoff curve (intro closed, build sweeps up with resonance climbing, drop wide open, breakdown half-lit) while the stab and bass filters get re-aimed from the same curve - harmony never develops, the filter is the form. The SIDECHAIN PUMP as a filter gesture: the strings' cutoff ducks at every kick and blooms across the beat (beat_pos() drives it). THE VOID: the last beat before every drop the whole band cuts to silence, then slams in from nothing. Harmony is a STOLEN PLAYBOOK of 4-bar loops transcribed from the records French house actually sampled - Modjo's Chic loop (i9-bVImaj7-iv9-bVII9), Stardust's Neapolitan bIImaj7, Braxe/Falke's i-bIII-iv, One More Time's tonic-avoiding IVmaj7-V-iii7 (the unresolved progression IS the longing), Digital Love's slash-chord bass - plus flavor rolls (the Lost in Music iv-to-IV9 dorian flip, the V melting to 9sus) and needle-drop rotation, spun the entire track. A seeded Da Funk riff on a held mono square with note_glide portamento owns the drops, and the 808 drums (kick boom, three-retrigger clap, metal-bank hats) are ON LOAN FROM tr808.c - house was born on that box. Seed on display (HOUSE_SEED / R / [ ] history), T tone, H help. Worked example #10 for docs/guides/game-music.md.

ink runner platformer

THE GROUND IS WHEREVER YOU HAVE PAINTED — the touching_color/pget showcase. An endless scroller: a tiny verlet walker trots along procedural ledges while you paint bridges and ramps with the mouse, racing the ever-faster scroll. There is no terrain data for the feet — each step scans the canvas downward for the first solid-colored pixel (ledge brown or your wet peach ink) and really stands on it. The walk cycle is emergent: planted feet are pinned in world space, so the scroll drags them back under the body like a treadmill. And the rescue: a runner that walks off an edge FALLS, but its dangling feet keep scanning — scribble under it and the feet catch the ink mid-air. Ink is metered and regenerates. Hold left mouse to paint, Z restarts, best distance saved.

mallet ⚡2×audio

INSTR_MALLET showcase - the second modeled ENGINE: every note strikes a bar simulation (four decaying sine modes + the mallet's contact click), so hits ring down and their partials fade at their own rates. Eight pentatonic bars + the same three engine macros every engine answers (instrument_harmonics = bar material, wood to bell; instrument_timbre = mallet hardness, soft yarn to hard brass; instrument_morph = ring length, dry tick to vibraphone sustain - the top third switches the motor tremolo on). The five presets (1 marimba, 2 xylophone, 3 celesta, 4 vibraphone, 5 glockenspiel) are nothing but knob positions - proof that named instruments are baked macro settings. A S D F G H J K strike bars, click or sweep across the keyboard for a glissando, 1..5 presets, drag the sliders (or LEFT/RIGHT + UP/DOWN), SPACE gliss run, M autoplay on/off.

multitouch paint

Finger-paint playground for the touch API. Every finger paints its own color at the same time - touch_id() keeps a finger's color stable while other fingers come and go - a new finger landing plays a mallet blip pitched by where it touched, and the CLEAR button shows tapp() edge-triggering: one tap, one clear. Best on a touchscreen: settings > Build for web, then open the LAN url from the build log on an iPad/phone on the same wifi. On desktop the mouse paints as a single finger.

pluck ⚡2×audio

INSTR_PLUCK showcase - the first modeled ENGINE (wave ids 16+): every note excites a Karplus-Strong string simulation instead of reading a wavetable, so plucks decay and darken on their own like a real string. Eight pentatonic strings + the three engine macros every future engine answers too (instrument_harmonics = ring time, instrument_timbre = pick brightness, instrument_morph = pick position) - turn a knob and hear the same string go from dead thunk to endless drone, felt thumb to hard pick, full to hollow. The read tap is fractional, so pitch reaches the string live - and the strings are real objects: GRAB one (press right on it) and drag to bend its pitch like a real guitar, or press in open space and sweep the pick past strings to strum them. V toggles a jangle-style chorus warble. A S D F G H J K pluck strings, drag the sliders (or LEFT/RIGHT + UP/DOWN), SPACE strum, M autoplay on/off.

re-201 space echo ⚡2×audio

Roland's RE-201 (1974) — a free-running tape loop, a record head, and an INTENSITY knob that feeds the tape back into itself; the box that made echo an instrument. Showcase cart for THE echo bus (the engine has exactly one, by design): a guitar string (INSTR_PLUCK) plays into the chamber, and five knobs map straight onto the new API — RATE is echo() time and the headline trick: sweep it while a tail rings and the repeats PITCH-BEND, because the bus's read tap glides like varying tape speed. INT is feedback, and past the red mark (>1.0) the loop genuinely self-oscillates — a tanh inside the feedback path saturates the runaway like tape instead of exploding; crank it and play the machine itself with the RATE knob. TONE is the loop filter (every repeat passes through it once, so tails get darker pass by pass — the thing scheduled-note echo could never do), ECHO is instrument_echo() send, DRV the pushed-tube input. SPACE toggles a sparse dub phrase that THROWS one note per bar into the echo with the send cranked for that single hit — the signature dub move. ZXCVBNM,./ + SDGHJL; play, UP/DOWN octave, knobs drag or wheel, H help.

roadhouse radio ⚡2×audio

Endless modal psych-rock - the Doors homage, station #13, built to carry THE IMPROVISER (melody brain #2): the first station whose band can take a SOLO. The jam form is head, organ solo, guitar solo, head out - and each 16-bar solo is improvised phrase by phrase: a 3-4 note motif invented at solo start gets stated, answered (inverted), sequenced up the mode, and doubled at the peak of a tension arc (density rises, register climbs, release comes home long), with breath rests between phrases. The improviser is PURE PERFORMANCE - engine rnd, never the seed - so R replays the song but the solos are new every time. A seeded 'how blue' knob biases b3/b7/b5 intrusions over the major-side vamp (the deliberate clash). The band: Vox-style combo organ - the FIRST station to use wave_set (a drawn drawbar cycle on INSTR_USER0); Rhodes PIANO BASS = the FM epiano detent an octave down playing a seeded swung ostinato; Krieger guitar = INSTR_PLUCK with an open-string drone ringing under the solo line; trio kit rolled shuffle / latin / rock. Mixolydian, dorian, or phrygian two-chord vamps (B-A forever). SPACE next jam, R same song new solos, [ ] history, LEFT/RIGHT feel (seance/lounge/jam/storm), UP/DOWN tempo, T tone, M power, B band (swap chairs live), H help.

satie radio ⚡2×audio

Endless gymnopedies and gnossiennes for solo piano - the Erik Satie homage, ninth of the radio family and its patron saint: Satie invented furniture music (musique d'ameublement, 1917), the idea every station on this dial descends from. Three engine firsts: 3/4 TIME (twelve-step bars), ONE INSTRUMENT (solo piano - the density curve shapes touch and ornament instead of layers), and chord brain #6, THE ALTERNATING PAIR: Satie rocks between two chords for bars on end (Gymnopedie No.1 is Gmaj7-Dmaj7 forever) and lets the pair itself drift between sections. Gymnopedie mode = modal maj7 pendulums, the suspended lilt (bass on 1, chord on 2, beat 3 empty); gnossienne mode = minor with the phrygian-dominant augmented 2nd, mordent ornaments, chord restruck on 3, rubato. Melody enters late, moves stepwise, holds over the barline. Real Satie tempo markings on the display. Seed (SATIE_SEED / R / [ ]), T tone, H help. Worked example #9 for docs/guides/game-music.md.

sh-101 ⚡2×audio

Roland's SH-101 (1982) — the guitar-strap monosynth, fourth box in the classic-machine family (cr-78, tr-808, tb-303), modeled on the real grey panel section for section: TUNE | MODULATOR | VCO | SOURCE MIXER | VCF | VCA | ENV, all vertical faders with tick scales, plus one mid strip holding the sequencer/arpeggio buttons, volume/porta, the AUTO/OFF/ON portamento switch and TRANSPOSE L/M/H — the finger-sized keybed owns the whole bottom half, with a vertical springy BENDER at its left end like the real lever. The SOURCE MIXER is the heart, like the hardware: pulse + saw + sub-osc + noise mixed SIMULTANEOUSLY on four faders (each source is its own engine voice, riding live on a held note via note_vol), with the 3-position sub switch (-1 oct / -2 oct / -2 oct pulse). MODULATOR: LFO with tri / square / random (S&H) / noise waveforms whose RATE slider is also the seq+arp CLOCK, exactly like the real LFO/CLK slider. VCO: MOD (vibrato), RANGE rotary (16' 8' 4' 2'), PW fader + source switch LFO/MAN/ENV. VCF: FREQ RES ENV MOD KYBD — five faders, all live on the ringing voice, with real keyboard tracking. VCA: ADSR or plain GATE. SEQUENCER: LOAD records key presses, PLAY loops them. ARPEGGIO: DOWN / U&D / UP buttons + HOLD latch. PORTAMENTO with the real AUTO/OFF/ON switch (AUTO glides only when legato), Mono, last-note priority. MULTITOUCH: every finger is its own pointer — hold a chord and ride the filter at once; fader grab zones tile each section so a near-miss grabs the nearest fader; sliding a finger across the keys hands the note over legato (AUTO porta glides). TUNE is live and reaches the running arp (instrument_tune). Two-manual computer keyboard covers all 32 keys: ZXCVBNM,./ + SDGHJL; lower, QWERTYUIOP + 2356790 upper, []= top, arrows = octave, SPACE = arp, ? = help.

tango radio ⚡2×audio

Endless tango - the Golden Age orquesta tipica homage (D'Arienzo's drive, Pugliese's yumba, Troilo's singing bandoneon), station #15. THE NEW BRAIN: TEMPO AS A VOICE - the first station where the clock itself is an instrument. A per-frame conductor eases a rubato multiplier toward phrase-shaped targets and drives bpm() live: a lean forward through every phrase, a real ritardando into every 8-bar boundary with a hard a-tempo SNAP on the next downbeat, and a long rallentando into the ending. Depth is seeded - every song breathes its own amount, and the bandoneon's bellows in the window breathe WITH the curve. Plus the tango kit nobody else has: MARCATO/SINCOPA alternation rolled per phrase (the accent ON the and-of-2), THE ARRASTRE (three crescendo bass graces dragged into the downbeat), chicharra/golpe percussion from the band itself (no drum kit at all), and THE CHAN-CHAN - every song actually ENDS: rallentando, near-silence, V7b9... home. Harmony: a minor functional walk in the harmonic-minor dialect (iio-V7b9 cadence forced, the Neapolitan bII, an Andalusian-tetrachord flavor roll) with parallel-major cantabile sections where the violin takes the song. Form: intro A B A B A VARIACION (continuous-16th bandoneon runs) final. The bandoneon is wave_set's second station gig: a drawn free-reed cycle with a bellows-tremble LFO. SPACE next tango, [ ] history, LEFT/RIGHT feel (salon/tanda/orquesta/pugliese), UP/DOWN base tempo, T tone, M power, B band (swap chairs live), H help.

tb-303 bass line ⚡2×audio

The acid machine — third box in the classic-machine family (cr-78, tr-808), but a monosynth, not a drum kit: ONE held voice (saw or square) through a resonant lowpass — the engine's FILTER_DIODE, a real diode-ladder model (~18dB/oct, bass drains as the resonance climbs, and the resonance saturates inside the loop so it growls, the way a 303 does) — sequenced from a mouse-drawn piano roll. All the 303 signatures: slide (a slid step doesn't retrigger — note_glide carries the pitch into the next note while the filter envelope keeps decaying, exactly like the real circuit), accent (louder + a harder filter kick), staccato gating at 70% of the step, and six draggable knobs — CUTOFF and RESO apply live to the ringing voice via note_cutoff/note_res (the entire point of acid), and DRV is the new instrument_drive/note_drive saturation: tanh AFTER the filter, so the resonant peak screams into it — RES + DRV up is the proper acid bite. Press N for a fresh random acid line (root-heavy minor pentatonic walk with random accents and slides, the honest way it was always done). The SQUELCH slider multiplies the env sweep up to 3x (full ENV + full slider = a 9kHz scream), and H opens a help panel with every control. Two authored patterns + the generator; LEFT/RIGHT pattern, UP/DOWN tempo, SPACE run/stop.

text fx lab

Animated text — the dialogue/title/HUD toolkit, eight effects each a 5-15 line technique you can lift straight into a game: typewriter (with the tick sound that sells it — X toggles), per-char wave, shine sweep, wipe reveal, damage-number shake, rainbow, and an outlined bounce. Two tools do most of the work: print() returns the x after what it drew, so printing one character at a time gives every char its own offset/color; and clip() turns into a reveal machine — a growing window wipes text in, a narrow moving window sweeps a shine across it. All effects loop forever; watch, then steal the one you need.

touch piano ⚡2×audio

A two-octave multi-finger piano - the touch-release API's first customer (touch_ended_count/id/x/y). Every finger landing on a key starts a sustained note; THAT finger lifting releases exactly its own note, even with four other fingers still playing - impossible before the release API, since a lifted finger has no touch index. Slide a finger across keys for glissando, hold up to 5-finger chords on iPhone (Safari's touch ceiling), ~10 on iPad. Lift ripples mark where each finger let go (touch_ended_x/y). On desktop the mouse is one finger.

touchlab

Device test card for the touch API - pick it up the day a real touchscreen is available. Build for web, open the LAN url on the iPad/phone, and run down the 7-point checklist on screen: crosshair accuracy under CSS scaling, ten-finger tracking, touch_id stability while other fingers tap, tapp() single-fire drumming, lift detection (cart-side diff - the data a future touch_ended API would return), iOS audio unlock blips, and whether Safari gestures leak (pinch/double-tap/edge-swipe must not move the page). Verdicts go to docs/design/touch-notes.md section 5. On desktop the mouse is one finger (id -2), enough to smoke-test half the card.

tr-808 rhythm composer ⚡2×audio

The big one — the TR-808 (1980), sibling cart to the cr-78 with the same editable grid, but built from the 808's actual reverse-engineered circuit values: the six-oscillator metal bank (800/540/522.7/369.6/304.4/205.3 Hz squares) shared by hats, cymbal and cowbell; the ~50Hz bridged-T kick with the famous decay-knob boom (+26 semitone pitch drop); the 180+330Hz dual-mode snare under snappy noise; rimshot/claves as one dual bridged-T circuit (1667+455 Hz vs 2500 Hz); and the handclap's three noise retriggers ~10ms apart plus a room tail. 16 voices, the iconic red/orange/yellow/white quarter-colored step buttons, six presets (Planet Rock, Healing, House, Electro, Boom Bap, Cowbell Jam), accents, and the anachronistic Z/X swing knob. Each voice has up to three 8×8 rotary knobs: T (tune ±12 semitones), D (decay 0.25×–4×), and a voice-specific character knob (SNPY noise/tone on snare, THUD on toms, TONE/RING on cowbell/cymbal/open hat). Drag Y=coarse, X=fine. Presets load with tuned knob settings. Closed hat chokes open hat. Q-H play voices, LEFT/RIGHT preset, UP/DOWN tempo, SPACE start/stop, click name to audition, drag knobs to shape.

tr-909 rhythm composer ⚡2×audio

The house and techno machine — the TR-909 (1983), fifth box in the classic-machine family (cr-78, tr-808, tb-303, sh-101) and the one that completes the ReBirth RB-338 rack. Same editable grid as the 808 cart, but the 909's hybrid voice architecture: analog kick/snare/toms/rim/clap (the kick is the HOUSE kick — fast +30-semitone sweep over 35ms plus a separate click layer on the famous ATTACK knob, punch where the 808 booms), while the hats, crash and ride — 6-bit ROM samples in the real hardware — are stood in by the FM engine: INSTR_FM parked on the 3.5 inharmonic clang detent with feedback cranked, through a highpass whose cutoff starts 5kHz low and rises via a negative ENV_CUTOFF amount = the fast-closing sizzle of a sampled hat. Closed hat chokes open, like the shared output stage of the hardware. And the swing knob is finally PERIOD CORRECT: the 909 is where Roland actually shipped shuffle (Z/X, even 16ths drag — the cr-78/tr-808 carts wear the same knob as an admitted anachronism). FLAM too — the panel's other humanize trick — and beyond: right-click CYCLES a cell through the stroke family — flam (one quiet grace note 22ms early, the Hardfloor clap signature), drag (two graces, the rudiment), ratchet (four even hits chopped across the step — not on the 1983 panel, but the fill techno lives on; Hardfloor's hat row ends on one). Cells draw their strokes as ticks. And one admitted impurity: a METAL-FILTER XY pad (bottom right) riding the highpass of all five metal slots — X = cutoff (left = darker/fuller), Y = resonance (up = the SVF peak rings) — because the FM stand-ins land bright and hissy without a tone control. 11 voices with up to three 8×8 rotary knobs each (TUNE / DECAY / ATTK-SNPY-CLIK-TONE), red TOTAL ACCENT strip, six presets: Good Life, The Bells, Energy Flash, Hardfloor, Revolution 909, Gabber. Q-A play voices, LEFT/RIGHT preset, UP/DOWN tempo, SPACE start/stop, click a label to audition, right-click for flams, drag knobs Y=coarse X=fine.

yacht radio ⚡2×audio

Endless yacht rock / AOR - the Steely Dan / Doobies / Hall & Oates homage, station #12 (second born on the radio.h scaffold). Built around THE MU CHORD - Steely Dan's named invention, a major triad with the added 9th voiced 3-5-9 - in stolen-playbook loop templates (the two-mu vamp, ii-V13 lush, maj7 PLANING, dorian funk) with mu-ify and sus-melt flavor rolls. The comping instrument is the FM epiano on the 1:1 detent, so the DX tine pings every chord; clean PLUCK strat stabs, breathy sax lead, chromatic bass runs INTO every change, citypop anticipations on the and-of-4, and a +2 gear change in the last chorus. Three kit personalities rolled per song: tight session 16ths, the PURDIE half-time shuffle (swung ghosts at vol 1), or CR-78 circuits on loan from cr78.c (the Hall & Oates 'I Can't Go For That' move). SPACE next song, R replay, [ ] history, LEFT/RIGHT feel (dock/cruise/regatta/open sea), UP/DOWN tempo, T tone, M power, B band (swap chairs live), H help.

ymo radio ⚡2×audio

Endless techno-kayo - the Yellow Magic Orchestra homage (Hosono/Sakamoto/Takahashi), eighth of the radio family, and the one genre where the synth isn't imitating anything: square waves and white noise ARE the original instruments. Sakamoto harmony as templates (the chromatic mediant 'Tong Poo' pull, maj7 planing in whole steps, the kayo minor cadence with its harmonic-minor V), a HOSONO BASSLINE GENERATOR (melodic 8th-note counterpoint with directional inertia and octave leaps - the bassline is a second melody), yonanuki pentatonic lead, a sequencer arp ticking chord tones, and drum voices ON LOAN FROM THE CR-78 CART (cr78.c's circuit recipes: soft round kick, two-layer snare, the swishy hats, the metallic clang) driven by machine-tight pattern strings. No swing, no lag - it's 1979 and the machine is the point. Seed on display (YMO_SEED / R / [ ] history), T tone, H help. Worked example #8 for docs/guides/game-music.md.

ambient radio ⚡2×audio

The night sibling of bossa radio: an endless AM station composing beatless ambient drift. Four held pad voices (note_on) morph between chords via note_glide portamento - the sound never stops; per-note LFOs add tape wow and filter breathing. Harmony is a weighted walk over one mode (lydian/dorian/mixolydian/aeolian), no cadences, just drift; sub bass glides under, wind and sparse bell arps above. Every song is a 32-bit seed on the display. SPACE next, R same dream again, [ ] history, LEFT/RIGHT feel, UP/DOWN pace, M power. Pin a favourite via AMBIENT_SEED. Worked example #2 for docs/guides/game-music.md.

blend lab

Can 32 colors fake real translucency? A cart-space prototype of BLEND TABLES (result = table[src][dst], always a palette index — the VGA/Doom/Picotron trick). 1: a night street where additive glows light the building behind them, 2: a draggable glass pane + cloud shadows + fog over a swatch sweep of all 32 colors, 3: the raw 32x32 tables. D shows the same shapes as today's fillp dither-fake for comparison; P reads dst via pget to demonstrate the one-frame feedback artifact. Arrows switch glass color / table. Zero new engine API — the experiment behind STATUS item 18.

bossa radio ⚡2×audio

An endless radio station that composes bossa nova. Every song is generated from a 32-bit seed shown on the display: key, AABA chord progression (Markov walk over jazz harmony - ii-V-I, tritone subs, backdoor dominants), voice-led guitar comping on the bossa clave, surdo bass, shaker, a One Note Samba-style melody cell, tempo, even the title. SPACE next song, R play the same chart again, [ ] song history, LEFT/RIGHT feel (layers), UP/DOWN tempo, M power. Pin a favourite: put its #seed in BOSSA_SEED at the top of the source. The worked example for docs/guides/game-music.md.

collision lab 1: points + boxes lab

An interactive lab that opens up the inside of collision detection. Collision is a YES/NO question asked every frame; this cart makes the question visible. Drag two boxes with the mouse and watch their AXIS SHADOWS on the top and left margins — two boxes overlap exactly when both shadows overlap (the green segments), which is why boxes_touch() is just four comparisons with no math. The four live comparisons are printed with real numbers and flip green/red as you drag. The cursor doubles as the point for point_in_box. Mouse drags the boxes, arrows nudge box A.

collision lab 2: circles + distance lab

Two circles touch when the distance between their centers is at most the sum of their radii — and this lab draws every part of that sentence. The right triangle between the centers shows Pythagoras live (dx leg, dy leg, hypotenuse = distance); a 1:1 ruler shows the distance shrinking past the ra+rb threshold; and the readout shows the NO-SQRT trick with real numbers: dist² <= (ra+rb)² is the same question using only multiplication — which is what near() and circles_touch() actually compute. The cursor doubles as the point for point-in-circle. Drag the circles, arrows nudge A.

collision lab 3: the world lab

Colliding with the ENVIRONMENT comes in three flavors, cheapest first. EDGES are pure math on your coordinates — press X to cycle clamp / bounce / wrap on the same wall and feel the difference. TILES are asked via the grid: the brown blocks live in the tile map, the cells the ball's box overlaps are highlighted live, and touching_map() just checks those. PIXELS are asked via the canvas: the green blob is not data at all — just drawn pixels — yet touching_color() collides with it by reading the screen back (the Worms-terrain trick). Live readouts include tile_at and pget under your cursor. Arrows fly the ball (it keeps momentum), X cycles edges, Z resets.

collision lab 4: circle vs box lab

New shape pairs reduce to old tests. Circle-vs-box (every ball vs every paddle) needs no new math — just THE CLAMP TRICK: clamp the circle center to the box on each axis and you get Q, the closest point on the box (drawn yellow, sliding along the edge as you orbit). Then it is lab 2 again: dist²(center,Q) <= r², squares only. The edge case comes free — center inside the box means Q equals the center, distance zero, touching, no special case. The full algorithm is printed live with real numbers. Drag either shape, arrows nudge the circle.

collision lab 5: lines lab

Two tests boxes and circles cannot do. POINT vs SEGMENT: project the mouse onto AB with the clamped t trick — the foot of the perpendicular is drawn, the grey band is the thickness, and then it is the distance test again. SEGMENT vs SEGMENT: AB crosses CD exactly when each segment has its endpoints on opposite sides of the other — four cross products, compare signs, no distances at all. This is the anti-tunneling test: a fast bullet path is a segment, so test the path and nothing teleports through walls (see linerider). Mouse is P, drag the four handles, arrows swing B across CD.

dutch sky

A day/night sky cycle over a flat Dutch horizon. 10 keyframes — midnight, pre-dawn, dawn, morning, noon, afternoon, golden hour, dusk, twilight — blended with a scanline dither. ← → scrub time of day. ↑ ↓ fly up through the atmosphere into space: sky compresses below, stars fill the black above. A toggles auto-advance.

galerijflat

A generative Dutch gallery-access apartment block at dusk. Each re-roll randomises the concrete scheme, railing style, and every household's archetype — vitrage + symmetrical plants = elderly, bare glass + TV flicker = student. SPACE re-rolls.

grid move maze

The third movement paradigm: position is a CELL, motion is a short tween between cells (the player is always logically at a cell, visually sliding to the next). The feel lesson is the TURN BUFFER — the Pac-Man cornering trick: press a turn a few frames before a junction and it's remembered, then fires the moment it's legal. It's the grid world's coyote time. Press X to toggle the buffer and feel every corner go sticky. Also shows bump-against-wall feedback and seamless cell-to-cell chaining. Eat all the dots. Arrows/WASD move, X toggles the buffer, Z restarts.

jangle radio ⚡2×audio

The afternoon sibling of bossa/ambient radio: endless feel-good mixolydian slacker pop, the Mac DeMarco / One Wayne G homage. Every song is a 2-4 chord vamp with NO bridge - the arrangement (intro/groove/solo/outro layers per loop) is the form. Chorused jangle guitar (constant 5.5Hz pitch-LFO warble), drum machine running 2-10ms loose behind the bass (sample-exact groove timing), tape tempo wobble, and a lazy legato lead that slides between mixolydian tones on one held voice via note_glide. Most songs are titled by date stamp, like the tape. Seed on the display pins the composition (JANGLE_SEED / R / [ ] history); the performance re-rolls. SPACE next, LEFT/RIGHT feel, UP/DOWN tempo, M power, H help. Worked example #3 for docs/guides/game-music.md.

jingle radio ⚡2×audio

The dusk sibling of jangle radio - the delicate side of the same songwriter. Composes from the actual Mac DeMarco harmonic playbook (Reverb Machine's chord-theory breakdown): progression templates from cited songs (Blue Boy, Dreaming, Stars Keep on Calling, Moonlight on the River, Another One, A Heart Like Hers), per-song bVII flavor rolls (maj/7/9) and borrowed bIII (maj7/m6), chromatic bass descents preserved in every key by a voice-led bass, real verse/chorus form, and the article's subtlest rule in code: MELODIC ACCOMMODATION - over a borrowed chord the melody narrows to that chord's own tones. Fingerpicked add9 voicings, gentle 4.6Hz warble, soft rim/hat kit. Seed on display (JINGLE_SEED / R / [ ] history), H help. Worked example #4 for docs/guides/game-music.md.

line rider sandbox

Draw a track with the mouse, hit Space and watch Bosh slide. Verlet physics — gravity, rolling friction, crash detection. Left drag: draw lines. Right click: erase. Space: play / pause. R: reset rider (or clear track while in draw mode). Arrow keys: pan. The rider's scarf trails behind when moving fast enough.

loopstation ⚡2×audio

A live-looper pedal — the first cart that RECORDS ITSELF. Four instruments share one 4-bar loop: arm a track, play, and what you played comes back around; layer the next instrument on top and you're a one-person band. Drums (Z/X/C), pentatonic bass (A-K) and lead (Q-I) record as discrete notes quantized to the 16th grid, so sloppy timing comes back tight. The THEREMIN (drag the pad: y=pitch, x=volume) records as a continuous gesture stream — note_pitch/note_vol sampled only when your hand moves — and replays it verbatim, drawing a ghost crosshair where your hand was. The loop ring shows every event as a dot on its track's circle. 1-4 select a track, SPACE arms record, M mutes, BACKSPACE clears, N toggles the click. The cart-land prototype for docs/design/input-recording-looper.md.

low end radio ⚡2×audio

Endless jazz-rap boom bap - the A Tribe Called Quest / Low End Theory homage, fifth of the radio family. Chord brain #5, THE SAMPLED LOOP: generates a lush modal-mixture soul progression (borrowed bIII/bVI/bVII voiced maj7/maj9, a 9sus dominant, the bVI as maj9#11 - per the r/musictheory Electric Relaxation analysis), then cuts a 2/3/4-bar loop (3 favoured) and ROTATES it like a crate-digger dropping the needle mid-phrase, so the tonic moves. Upright-ish bass front and center leaning +12ms, full groove template (hats rush -8ms, snare drags +22ms, 16ths swung 57%), Q-Tip layered snare (noise crack + sine thump as one hit), tremolo rhodes stabs, vinyl dust, hook lead narrowed to each chord's tones. No tempo wobble - samplers don't drift. Seed on display (LOWEND_SEED / R / [ ] history), H help. Worked example #5 for docs/guides/game-music.md.

monster mix lab arcade

Assemble the monster the customer ordered, then STAMP it with the piston press. The sprite side is the show: tools/sprite-draw.js draws 9 parts (3 heads, 3 bodies, 3 legs) and stamp()-composites all 27 combos at bake time; the magic pal() indices (28/29) recolor them into 4 schemes at draw time — 108 monsters from 9 drawn parts. Also: a 32-wide machine split() across two slots, a concave polyfill star, noise() speckle tiles, mirror()ed symmetric parts and outlined() borders. Right order = points + a streak of climbing chords; wrong or too slow = a lost heart. LEFT/RIGHT choose a slot, UP/DOWN change the part, Z stamps.

oil plate

Liquid light show, Voronoi style. Three large coloured blobs (orange, blue, red) drift slowly; each pixel is owned by the blob with the highest field — flat colour regions with a bright iridescent seam exactly where two blobs meet. Small dark bubbles float inside the regions and get a bright ring for free from the same seam logic. A re-rolls.

oil show

Liquid light show — five metaballs drift across the screen; the scalar field at each pixel drives Bayer ordered-dithering between adjacent palette colours, giving the oily iridescent edges where blobs merge. The whole colour scheme slowly drifts through the rainbow. A re-rolls the blobs, B pauses the colour drift.

palette lab

Try on a new default palette and judge it where it matters most: BLENDING. This is blendlab x palettes — the Layer-1/1b probe from palette-and-color.md with blendlab's scene-function architecture ported in, so every blend runs against the LIVE candidate. Keys 1-9, 0 and A swap the palette (or click the top HUD bar to cycle - left-click next, right-click back): shipped PICO-8 / ENDESGA 32 / full RESURRECT 64 / E32 + 32 derived in-betweens (sRGB ramp midpoints + hue bridges, computed in-cart) / ENDESGA 64 (the same author's own curated expansion — candidate 4 vs 5 is generate-vs-curate head to head) / AAP-64 (the other canonical long-ramp 64) / FAMICUBE (the opposite philosophy: a fictional console's identity palette, distinct hues over dense ramps — watch its glows ring in the wrong family) / JOURNEY (the painterly school: violet-cast darks, ramps that bend through hue — even its black is a midnight blue) / JEHKOBA64 (the lattice school: hue-family ramps of five, every hue given the same value treatment — does a systematic grid blend more predictably than hand curation?) / ROSY 42 (key 0, PineappleOnPizza's 42-colour painterly set - 32 role-mapped + 10 leftovers, pal_n=42, no neutral grey) / DB32 (key A, DawnBringer 32 = Aseprite's default new-sprite palette and the de-facto pixel-art standard - the most important baseline to beat, and the first candidate with a real neutral-grey ramp). LEFT/RIGHT walk six scenes: the 64-swatch grid + five dithered corpus ramps, a sunset, a portrait (skin tones are where palettes get cruel), the NIGHT GLOW street with real additive streetlights (D toggles today's fillp fake next to it; carry a glow on the mouse), GLASS+FOG (translucent pane on the mouse, C cycles its color, drifting MUL cloud shadows, an AVG fog band), and the raw BLEND TABLE grid (T cycles AVG/ADD/MUL). The AVG/ADD/MUL tables rebuild from the candidate's RGB on every switch — more/denser colors visibly band less. Note the dither scenes only reference slots 0-31, so candidates 2 and 4 are identical there by construction; the blend scenes are where 32 vs 64 separates. Built on the EXPERIMENTAL palette_hex() + the 64-slot palette.

sfx editor

Draw a sound, PICO-8 style. Paint a pitch contour over 32 steps with the mouse (left = draw, right = erase), shape the volume lane and the filter CUT lane (top = wide open, lower = darker; a RES slider adds squelch), pick a wave per step, set the speed, SPACE to hear it. A SCALE picker (major/minor/penta/blues/hexatonic/whole-tone + a KEY root; click cycles, right-click cycles back) snaps painted notes in key, with faint row guides showing where notes can land — OFF for chromatic freehand. Press E to EXPORT the sound as C code — a step array plus a tiny player function — printed to the log, ready to paste into your game (no engine sound banks needed: playback is just hit() per step). S/L save and load, LOOP toggles looping, BACKSPACE clears. The prototype for cart-authored sfx (audio-notes §5.6).

sfx generator

Sliders make the sound — a dreamengine take on sfxp/bfxr. Three lanes (AMP, PITCH, WAVE), each with hold/decay and an LFO: 17 sliders GENERATE a 32-step sound, the colored curves show the result, and every change replays it. RANDOM for instant inspiration, MUTATE to refine what you almost like (the game-jam workflow), arrows undo/redo, Z replays. Press E to export the baked steps as paste-ready C code — the same format as the sfx editor cart, so either feeds your game the same way. S/L save and load.

sound check

The sound engine self-test. init() slams the request queue with the worst-case burst (all 27 instrument slots defined with envs/LFOs/filters + all 4 user wavetables in one frame), then walks the whole API: every wave id audibly in sequence, chords, a 40-shot schedule_hit machine-gun, and a held note driven by every live setter. PASS = no [sound] WARNING in the log and all 9 waves sound different; the engine now counts dropped requests and screams if any sound call was lost. Headless: node tools/play.js soundcheck run.

sprite foundry

Watch the code draw. Every sprite in this cart was generated by tools/sprite-draw.js, and the sheet holds each subject's time-lapse: foundry.cart.js snapshots the canvas into the next slot after every drawing step, and the cart plays the construction back with the line of code that produced each frame. Three subjects, three money shots: a dragon lit by the new shade() ramps, a mirror()ed ship spun through 8 rotations() headings, and a boss that gets noise() warts, a replace() recolor and a scale2x() upscale into a 2x2 slot block. LEFT/RIGHT step, Z autoplay, UP/DOWN switch subject.

steer (car drift) racing

The car model — the second half of the steering paradigm. thrust showed facing and velocity fully decoupled (a spaceship); a car is the in-between: velocity is PARTIALLY coupled to the facing, and the coupling strength is GRIP. Three rules: turning scales with speed (a parked car cannot turn — try it), the gas pushes along the heading, and each frame the velocity lerps toward the heading — fast lerp carves, slow lerp DRIFTS. Skid marks appear exactly when the lateral slide exceeds the tires. The green line is where you are going, the nose is where you point. X swaps racing tires for drift tires. Collect the cones. LEFT/RIGHT steer, UP gas, DOWN brake, X tires, Z restart.

thrust (inertia) space

The fourth movement paradigm: steering & inertia. The ship has a FACING and a VELOCITY and they are not the same thing — turning moves nothing, thrusting pushes along the facing, momentum carries you, drag bleeds it off. The green line shows where you are GOING while the nose shows where you are POINTING: watch them disagree mid-drift. Press X for tank mode (velocity = facing, release stops dead) and feel how much of the asteroids sensation IS the inertia. Collect the stars; the screen wraps. LEFT/RIGHT turn, UP thrusts, X toggles inertia, Z restarts.

wave editor

Draw the actual waveform. The engine has four custom wave slots (INSTR_USER0-3), each a 64-sample single cycle — paint that cycle with the mouse and hear it instantly. The killer trick: SPACE starts a drone, then redraw the shape while it rings — wave_set() is live, so the timbre morphs under your pen. Seed shapes (sine, square, saw, organ, vocal, wobble) plus SMOOTH and NORM, A-K play notes, P toggles an arp. Press E to export wave_set() code; your drawn wave then works everywhere a wave id does: note(), instruments, the other sound carts.

zelda walk (grid nudge) maze

The secret middle ground between grid-move and free movement, rebuilt the way NES Zelda 1 actually did it (per the community deconstructions). Three pieces: an 8px HALF-GRID (you are never more than 4px off); PASSIVE REALIGN while walking — the perpendicular axis corrects 1px per pixel walked, so 4px off = realigned after 4px, almost invisible; and CORNER FEELERS — the crosswise hitbox is only 8px wide, so clipping a corner blocks just one feeler and you get shoved around it while you keep walking (your outer pixels may overlap the wall, the classic Link look). Free feel, grid forgiveness. Collect the gems, then press X to switch the assists off and feel the same room become constant corner-snagging. Arrows/WASD move (4-way), X toggles, Z restarts.

dual env

A Minimoog/Model-D-style bass rig: THREE oscillators (two detuned saws + an octave-down triangle sub) through the Moog ladder filter, with a FILTER contour, a cutoff LFO, a LOUDNESS ADSR, plus DETUNE, DRIVE and a FAT low-shelf EQ for the low-end 'humpf'. Each control has its own slider/toggle and a live graph. Subtractive-synth fattening, demonstrated. The voice is two sawtooths (instrument_tune detunes the second a few cents → they beat = thick) through FILTER_LADDER (the Moog 4-pole), warmed by instrument_drive in DRIVE_ASYM (even harmonics = round grit). Graph 1: the FILTER cutoff — the one-shot ENV snaps it open on the attack, the LFO wobbles it continuously. Graph 2: the AMP envelope — what decides how LONG you hear the note (low sustain plucks and dies, high sustain rings to note-off, the red line). Row 3 is two views side by side. LEFT, SHAPE: a still idealized single cycle — a saw through a resonant filter (CUT rounds the corners, RES adds the ring), clipped on one side by DRIVE, plus the octave SUB; it redraws only when you change a SHAPE knob. RIGHT, SCOPE: the ACTUAL output via the scope_read engine API, zero-cross-triggered to hold still — the real signal, so the envelope sweep / LFO wobble / detune beating you DON'T see in the still shape all show up here, live. DETUNE/DRIVE plus the SUB OSC (octave triangle) and FAT EQ toggles are where the humpf lives. MONO makes it a one-note-at-a-time bass like a real Model D: every note chokes the last and RETRIGGERS the filter-env thump, snapped cleanly to pitch — punchy, with no polyphonic wash. A-K play notes - SPACE toggles the auto-arp - MONO / FAT EQ / SUB OSC toggles top-right - drag the FILTER / LFO / AMP / VOICE sliders

lounge larry dating

A branching chat-up in the style of Leisure Suit Larry. A woman's big face fills the screen — drawn entirely from primitives (ovals, triangles, lines) — and her expression shifts happy/annoyed/angry/sad in real time as you pick what to say, with a live VIBE meter tracking how it's going. Land the smooth lines and she slips you her number; push your luck and you wear her martini; there's even a recovery path back from a bad opener. The whole point: there is NO dialogue 'engine' — branching conversation is just a table of nodes + an int for 'where am I' + an int for 'how much she likes me', drawn with print() and btnp(). No new API needed. Up/Down or 1-2-3 to pick a reply, Z to choose (or click a line).

mandala pad

A generative visual instrument — the drawing cousin of the synth carts. You don't place pixels by hand (that's Deluxe Paint); you make ONE gesture and a kaleidoscope does the rest. Every stroke is mirrored across N radial sectors (and optionally reflected), so a careless squiggle blooms into a symmetric mandala — and in RAINBOW mode the colour flows along the stroke, so it's almost impossible to make something ugly. LEFT-drag paints, RIGHT-drag erases, wheel/[ ] sizes the brush, LEFT/RIGHT change the sector count, M mirror, V colour mode (solid/rainbow/rings), G guides, H hides the UI for a clean screenshot, C clear, N new, S save.

paint a level platformer

The same pixel-perfect platformer mover as 'platform engine (rects)', but the level is painted, not coded. Edit sprite slot 0: 1 pixel = 1 block, and the color is the type — brown solid, light-peach one-way, red hazard, yellow coin, green spawn. At startup the cart reads the sprite back with sget() and builds the world, so repainting the sprite makes a whole new level with no code change. Collect the coins, avoid the red spikes. Arrows/WASD move, Z or up to jump.

pitch env

Punch & zap — a one-shot envelope (instrument_env + ENV_PITCH) that starts a note some semitones off its real pitch and lets it settle back over the decay. Big amount + fast decay on a low note is the "donk" of a kick drum; medium settings are lasers and zaps; a tiny amount adds an attack chiff. The graph shows the pitch blip; drag the five sliders (attack, decay, amount, note, length), W cycles the waveform. Same mod-envelope as filter env, pointed at pitch — still no instrument engine. A-K play, SPACE toggles the auto-pulse.

platform engine (rects) platformer

A pixel-perfect platformer feel built from nothing but colored rects. The level is an array of solid boxes; the player moves with floats and resolves one axis at a time. Includes coyote time, jump buffering, variable jump height, squash/stretch, and one-way platforms (the lighter ledges — jump up through them, land on top). Press X to toggle the feel assists and feel the difference. Tuning lives in #defines at the top: run it in live mode, edit GRAV/JUMP_V/COYOTE and hot-reload in place. Arrows/WASD move, Z or up to jump.

platform rails (slopes) platformer

The OTHER kind of platformer. The rects/paint/tiles carts use solid-space collision (free position, gravity always on, collision discovers the ground) which can only make flat ground. This is the rail model behind Donkey Kong, Lode Runner and BurgerTime: the player is bound to a girder, so position is 'which girder + how far along it' and height is just a formula (py = surface(pg, x)) — which means SLOPES come for free. Ladders connect the girders; the player is a run/climb/jump state machine. Run up the slanted girders, climb the ladders, reach the flag. Arrows/WASD move, up/down climb a ladder, Z to jump.

rail loop (sonic-style) platformer

Curved rails and edge attributes — the follow-up to 'platform rails'. The rail no longer has to be a straight girder: sample any curve into a list of points and the player's position becomes a float INDEX into that list, so a Bézier hill and a full LOOP are the same code. A Sonic loop 'just works' because the player is glued to the track (no free-fall on a rail) — running it is only advancing the index around the circle, upside-down at the top and all. The orange stretch is a CONVEYOR: an edge attribute that carries you forward on its own (same idea as a one-way ladder — behaviour attached to part of the graph). Roll over the hill, through the loop, across the conveyor, to the flag. Arrows/WASD move, Z to restart.

the love parade

A generative toy in the rectangular style of Donkey Kong and Boulder Dash — every little person and animal is built from rectfill/circfill (no sprite art), from a random bag of GENES: proportions, colours, haircut, clothing pattern (sometimes), head shape, ears, tail, neck, horns, wings, antennae, eyes. Roll endlessly and a parade strolls past across depth lanes, never the same one twice. The hook: PICK ONE UP and drop it on another and they BREED — an offspring pops out (a tiny baby that grows up over ~10s), its genes a 50/50 mix of the two parents plus the odd mutation. Breeding only ever happens when YOU trigger it. Crazy outcomes: person × beast can make a CENTAUR, two humans can make a HUMAN-ON-ALL-FOURS, and giants/cyclops/winged hybrids turn up. Drag a critter onto another to breed; SPACE re-rolls the crowd; right-click adds a newcomer.

tilemap platformer platformer

A great-feeling scrolling platformer where the world is a tile map (drawn as colored rects by tile type). The same polished mover as 'platform engine (rects)' — per-axis resolution with flush tile snapping, sub-pixel motion, coyote time, jump buffering, variable jump height, floaty apex, squash/stretch and landing dust — but on tile collision with a camera that scrolls a world bigger than the screen. Collect coins, stomp the purple critters from above, dodge the red spikes, reach the green flag. Arrows/WASD move, Z or up to jump.

traffic jam

A generative cars toy in the rectangular style of Donkey Kong and Boulder Dash — every vehicle is built from rectfill/polyfill/circfill (no sprite art) from a random bag of GENE-DIMENSIONS rolled within its TYPE, so the same sedan is never the same sedan twice. Ten knobs vary one car: length, body height, roof height, cabin length, cabin position, windscreen rake, backlight rake, wheel radius, ground clearance, wheelbase — plus colours, two-tone, passengers, spoiler, roof-rack, antenna. 17 types: micro, hatchback, sedan, wagon, SUV, MPV, coupe, sports, supercar, muscle, luxury, convertible, antique, pickup, van, bus, and a long-ass semi truck — each with a driver and passengers visible through the glass. They roll past in a four-lane procession governed by a TRAFFIC LIGHT: go red and a stop-and-go jam piles up behind the line and ripples backward (real car-following), go green and it flows. Click a car to HONK, click the light (or L) to flip it, SPACE re-rolls the fleet.

24. moving patterns

fillp_anchor(): why a fill pattern 'crawls' under a MOVING shape and how to stop it. By default the 4x4 lattice is pinned to the world, so a shape that drifts just slides across it. Anchor the pattern to each shape's own center and the dither travels WITH it. Nine spinning, bouncing two-tone shapes (polygons + stars), each its own fg/bg color and pattern. Z toggles anchoring off so you can watch the crawl come back.

dino run platformer

Chrome-offline-dino homage. You auto-run to the right — jump over cacti and duck under pterodactyls before they clip you. Speed climbs the longer you last, gaps between obstacles shrink, and birds only start appearing once you hit 300. Z / Up to jump; Down to duck. Score and best run saved.

dreamcad

A picoCAD-style 3D model editor. Orbit camera in perspective view, three orthographic views (Tab to cycle). Object list in the sidebar. v1: view the default cube, orbit and zoom with mouse. More editing coming soon.

glass harmonica ⚡2×audio

Ben Franklin's rubbed-wine-glass contraption, built on the HELD NOTE api. Seven nested glass rings each hold a sustained sine voice (note_on at vol 0 — alive but silent); you never trigger them, you RIDE their volume. HOLD the mouse and slide IN and OUT across the rings: whichever one your finger wets swells in with a slow attack (note_vol), neighbours bleed so sweeping between rings blooms a glassy chord, and it all fades slowly when you let go. Bigger ring = lower note; pitches are a major pentatonic so any combination stays consonant. Pure, ghostly, polyphonic — the opposite of a struck note.

held notes ⚡2×audio

A theremin built on the new HELD NOTE api. Press and HOLD anywhere on the pad — one sustained voice starts (note_on) and rings until you release (note_off). While you hold, the mouse drives it live: X slides the pitch (note_pitch), Y sweeps the filter cutoff (note_cutoff). This is the opposite of fire-and-forget note(): a voice you keep talking to. The building block behind engine revs, sirens, charging lasers, and real hold-to-sustain keyboards.

hurdy-gurdy ⚡2×audio

The cranked drone-fiddle, built on the HELD NOTE api around a mechanic nothing else uses: the crank IS the sound. HOLD the mouse and CIRCLE it around the wheel — TWO expressive axes from one gesture: how FAST your hand travels = loudness, how WIDE you circle = brightness (note_vol + note_cutoff across all three voices). Drone voices (tonic + fifth) only sing while the wheel turns. Press a tangent key (A S D F G H J K) to stop the melody string at a pitch (note_pitch), highest key wins; keys 1-5 switch the scale (major/minor/penta/p-min/blues). The 'chien': a sharp FLICK of the crank snaps the buzzing dog bridge for a percussive accent — toggle it with B. Watch the CRANK and TONE meters and the coloured contact ring.

modrack ⚡2×audio

A tiny modular synth, built in steps. STEP 1: the generative Berlin-school chain is hardcoded in C — CLOCK ticks a SAMPLE & HOLD that freezes a wandering LFO, a QUANTIZER snaps it to a scale (always in key), and a VOICE plays it as a held note whose filter the same LFO sweeps live. Endless in-key melody, zero composition. Later steps draw editable module strips and patch cables. Built on the held-note API (note_on/note_pitch/note_cutoff).

musical saw ⚡2×audio

The theremin's spooky cousin, and the one cart that drives note_lfo LIVE — the vibrato is something you PLAY, not a fixed setting. One sustained sine voice (note_on) bowed and bent by hand. BOW it: hold the mouse and saw LEFT-RIGHT — your bow speed is the volume (note_vol), so it dies when you stop, like a real bow leaving the blade. BEND it: up/down flexes the steel blade into a deeper or shallower S-curve and the CURVATURE is the pitch (note_pitch + note_glide for the smear). SING it: wobble your hand vertically while bowing and that wrist-shake feeds a live note_lfo vibrato whose depth AND rate climb with how hard you shake — you hear it shiver and watch the blade shimmer. Ethereal, vocal, haunting.

otamatone ⚡2×audio

The little face-on-a-stem toy, built entirely from the HELD NOTE api. DRAG the vertical stem to play — one sustained voice (note_on) whose pitch chases your finger up and down the fretless ribbon (note_pitch + note_glide for the signature slurp). Hold SPACE (or right-click) to squeeze the mouth open: that sweeps a resonant lowpass from a muffled 'mm' to a bright 'aah' (note_cutoff), and the pixel mouth opens to match. Wiggle while you slide for hand vibrato. Q toggles fretless ↔ snap-to-pentatonic.

stylophone deluxe ⚡2×audio

The pocket stylus-synth, built to reach two corners of the audio engine no other instrument cart touches. LIVE PULSE-WIDTH: the TONE fader morphs the buzzy square's duty by hand (note_duty), thin/nasal to hollow/fat. THE TRANSPORT: the famous REITER (reiteration) switch retriggers the held note in time with the tempo (bpm + beat + beat_pos) — the cabinet's first tempo-synced instrument; crank RATE up and it machine-guns, flip ARP and the retrigger walks a major arpeggio. Play it with the STYLUS (the mouse): touch the metal keyboard and slide for the classic glissando (note_pitch stepping pad-to-pad). VIBRATO and SUB (sub-octave) are switches, like the real deluxe panel. Watch the BEAT lamp pulse with the transport.

trifill stress

A spinning pinwheel of long, thin software-filled triangles — and a tiny lesson in why off-screen drawing used to cost you. Each spoke's far vertices sit way outside the 320x200 screen, so its bounding box is enormous while only a sliver is ever visible. The engine's CPU triangle filler used to scan that whole box, almost all of it off-screen and empty, which dragged a dozen spokes down to ~20fps — until the renderer learned to clamp the scan to the on-screen region. Now the off-screen reach is free (crank it to the max and it stays at a smooth 60fps); only on-screen coverage costs. A renderer regression test, not a game: it proves the clamp holds. The live fps counter turns yellow then red if it ever falls again. Up/Down add or remove spokes (on-screen cost), Left/Right grow or shrink the off-screen reach (now free), A freezes the spin to hold a steady frame.

Battleship tabletop

Classic two-grid naval Battleship against a scheming CPU. Set up your fleet of five ships on the left ocean — a ghost ship snaps to the cursor and turns red when it won't fit — then trade salvos with the hidden enemy grid on the right. Hits flash and shake the screen with a low boom, misses splash, and a major-chord sting rings out when you sink the Carrier, Battleship, Cruiser, Submarine, or Destroyer. The enemy fires back with a hunt-then-target AI: random checkerboard shots until it draws blood, then it probes the neighbours of its last hit until your ship is dead. First fleet sunk loses; wins and losses are tallied across runs. SETUP: move the mouse to aim, click to place, R to rotate, click RANDOM to auto-fill, click READY to fight. BATTLE: click an enemy cell to fire. GAME OVER: click or press Z to play again.

Beatcrypt rpg

A beat-locked roguelike: a looping 2-bar synth bed (kick/snare/euclidean hats + a minor bassline) drives turn-based dungeon crawling — move/attack ONLY on the beat to build a combo, miss the window and you stumble; enemies step on their own rhythms (skeleton every 2nd beat, bat on a euclid(3,8) syncopation, slime every 4th). Bump enemies on-beat to kill, clear the floor, reach the > stairs. Controls: WASD / Arrows to move + attack (press ON the beat), R to restart.

Bejeweled puzzle

An 8x8 well of faceted jewels begging to be matched. Click a gem, then a neighbor, to swap them — but the swap only sticks if it lines up three or more of a color; an illegal try wiggles back for free. Matches flash white and shrink into a spray of colored sparks, the gems above ease down into the gaps, fresh ones stream in from the top, and every new line the fall creates cascades for a climbing score and a chord that pitches up with the chain. Run the board dry of legal moves and it reshuffles itself; spend your 30 swaps for the high score, which is saved between runs. Mouse only: click a gem then an adjacent gem (or drag from one to a neighbor) to swap; click to play again on game over.

Blackjack tabletop

Sit down at the felt and play the casino classic against a by-the-book dealer: push out a bet from your bankroll, take two cards against the dealer's one-up-one-down, then hit, stand, or double down. Aces ride soft (1 or 11), a two-card 21 pays 3:2, the dealer hits 16 and stands on 17, and the whole table is drawn from crisp card primitives with cards that ease in off the deck, a hole card that flips on the reveal, a rising chord on a win and a red-flashing screen shake on a bust. Your bankroll persists between runs via save(), so the slow grind of the house edge follows you home. Controls: BETTING — Left/Right or A/D to lower/raise the bet, Z or Enter to Deal; YOUR TURN — Z Hit, X Stand, C or Down Double; RESULT — Z or Enter for the next hand (Z rebuys when broke); or click the on-screen buttons.

Bloom

A calm L-system turtle garden at twilight: click the soil to plant a seed (cycles fern/bush/tree), then press space or X to advance a day and watch every plant rewrite its L-system one iteration further — sprouts branch into ferns, bushes, and trees that sway in the wind. Controls: click or Z to plant, space or X to advance the day.

Boggle word

A pocket word-hunt: sixteen weighted-random letters in a 4x4 grid, a 90-second clock draining across the top, and a single mission — trace as many real words as you can. Press a tile and drag the mouse across orthogonally or diagonally adjacent letters; a glowing yellow chain follows your path and the word builds live beneath the board. Release to submit: 3+ letters that hit the embedded ~2500-word dictionary score by length with an ascending chime and a green pulse, while junk or duplicates buzz and shake the screen red. When the timer empties the board freezes and tallies your words and points against your saved best. Drag the mouse across adjacent letters to trace a word and release to submit; R reshuffles or restarts after the round ends.

Boulder Dash arcade

Tunnel through a dirt-packed cave for diamonds while boulders and gems obey gravity — dig out what holds a rock up and it falls, rolling off the rounded tops of other rocks into open gaps, and a falling rock crushes you (or a wandering enemy) flat. Grab the diamond quota to flash the exit open, then scramble to it before the timer runs out. The cave settles on a steady tick so falling stacks cascade one cell at a time, and the camera follows your miner across a cave bigger than the screen. Arrows step and dig in a direction; walk into a boulder sideways to push it into an empty cell beyond; R or B restarts the cave.

California Games: Half-Pipe sports

Carve a neon half-pipe under a banded synthwave sunset in this Epyx-style vert event. Your skater swings wall to wall as a pendulum: tap PUMP at the bottom of the ramp (on the beat for extra pop) to build speed, fire off the lip into the air, then throw kickflips, 360s, methods, indys and ollies for points that only bank if you stick the landing upright over the wall — over-rotate and you BAIL with a screen-shaking slam. A filtered synth bass, euclidean hats and a pentatonic arp react to your airtime over a 60-second high-score chase with a saved best. Controls: Down/Z = pump at the bottom; in the air Z = kickflip, X = 360, Left/Right = method/indy grab, Up = ollie/straighten; Z or X to start and restart.

Centipede shooter

The arcade classic, drawn entirely from chunky primitives. A segmented bug winds down through a field of mushrooms toward your blaster, which is pinned to the bottom band of the screen. Every shot counts: blast a mid-body segment and the centipede splits in two while a fresh mushroom sprouts where it died; pick off the head and the swarm just shortens. A glittering spider darts through the lower third, eating mushrooms and hunting you for a fat 300-point bounty. Clear every segment to march into a faster wave; lose all three lives and your run is over. Lives, score, and a saved high score. Arrows/WASD move (bottom band only), Z/Space fire upward, Z to restart on game over.

Chess tabletop

A complete, legal game of chess on one crisp 8x8 board — every piece move, captures, castling, en passant, pawn promotion, and full check / checkmate / stalemate detection, on a primitive-drawn board with readable pixel-art piece sprites (authored in code via sprite-draw.js). Play two-player hotseat or face a depth-3 negamax CPU that weighs material and central control, picking either color. Pick up a piece and its legal squares light up (dots for moves, rings for captures), the last move leaves a trail, a checked king flashes red, and checkmate lands with a fanfare and a screen shake; a tiny win tally persists between sessions. Controls: click your piece to select (legal targets highlight), click a target square to move, click the piece again to deselect; on the title screen click HOTSEAT or VS CPU (white/black); in game R starts a new game and M or ESC returns to the menu.

Civ (tiny) 4x

A pocket-sized 4X on a fogged continent: start with one settler and one warrior in a sea of black, walk out, found cities, and watch the unknown peel back tile by tile. Cities grow a population bar and pump out a fresh unit every few turns while a single research bar slowly fills and unlocks Irrigation — the one improvement, which makes every city grow faster. No rivals, no war, no diplomacy; the map and the clock are the opponent. Found 3 cities before turn 30 to win, with your fastest run saved as a best. Controls: click a unit then click an adjacent revealed tile to move (1 tile/turn), B to found a city with a settler, E (or END TURN) to advance the turn, click for a new continent after the game ends.

Columns puzzle

The SEGA arcade gem-dropper, distilled. A vertical column of three jewels falls into a narrow well — you can't reshape it, only slide it left and right and cycle its three colors mid-fall. Land 3 or more of a color in a line (horizontal, vertical, OR diagonal) and they flash, clear, and the stack collapses — fresh matches cascade into escalating chains that ring out as a climbing arpeggio while the screen kicks. Speed ramps as you clear, best score is saved, and stacking to the top ends the run. Left/Right slide, Up or Z cycle the colors, Down soft-drops, Z/X restart.

Connect Four tabletop

The kitchen-table classic against a real opponent. Discs clatter down a blue 7x6 grid — you drop red, a depth-5 alpha-beta minimax AI answers in yellow, each disc accelerating under gravity into the lowest open slot with a rising blip and a tiny screen kick on landing. Line up four in any direction — horizontal, vertical, or diagonal — and the winning run flashes white while a major chord rings out; lose and the board sinks under a low saw growl; fill it with nobody connecting for a draw. Your running win/loss/draw tally is saved between runs. Hover a column and left-click to drop, or use A/D or Left/Right to aim and Space/Z to drop; click or Space/Z to play again.

Deckbuilder rpg

A Slay-the-Spire-grain dungeon run boiled to its core: three nodes, three fights, one boss. Spend 3 energy a turn on a hand of cards — STRIKE and BASH chip the foe's HP, DEFEND and BULWARK raise BLOCK that soaks the next hit — while the enemy telegraphs its INTENT (a sword + number) so you can plan the trade. End your turn, watch the grunt resolve, drop it to zero, then pick one of three reward cards to fatten your deck before walking to the next node. Beat the horned Dread Knight to clear the run; your win count is saved between sessions. All hand-drawn from primitives with floating damage numbers, hit-flash, screen shake, and a punchy little synth. Click a card to play it on the enemy, click END TURN to let it act, click a reward to keep it (or SKIP), and click the next map node to advance; keys 1-5 play hand slots, ENTER ends the turn, SPACE continues.

Defender shooter

Skim a fast little ship over a wrapping mountain world far wider than the screen, while alien Landers drift down to snatch the humanoids walking the ground and haul them skyward — let one reach the top and it MUTATES into a fast, swarming red killer. Blast a carrying lander and its human plummets: dive, catch it midair, and lower it home for big points. A scanner strip across the top maps the whole ring-shaped level — ship, aliens and humans as blips — so you always know where the danger is. Clear every alien to advance the wave; lose all your humanoids and the planet is lost. Arrows fly and thrust (left/right faces + scrolls the world), Z fires forward; press Z to start and to play again.

Dig Dug arcade

A little digger dropped into a field of solid earth — walk and you carve tunnels through the dirt, the passages staying behind you in earthy depth-banded layers. Two monsters lurk in the soil: round red Pooka and green fire-breathing Fygar. Pop them two ways — face one down a tunnel and hold the harpoon to pump it full of air until it bursts, or dig out the dirt beneath a teetering rock so it crashes down on its head. Corner a monster too long and it flattens into floating eyes that ghost straight through the dirt to hunt you. Clear every monster to dig a deeper, busier layer. Arrows move/dig and aim, hold Z to pump; Z again to continue after a clear or game over.

Donkey Kong platformer

The arcade 25m girder stage, rebuilt from pure primitives: a tower of slanted red girders strung together with peach ladders, Kong thumping barrels off the top, and the princess blinking HELP at the summit. Run up the slopes, climb the ladders, and time your jumps as barrels tumble down and randomly peel off onto a ladder — clear one for +100, or grab the blinking hammer for six seconds of barrel-smashing frenzy. Touch a barrel without the hammer and the screen flashes red and shakes as you lose one of three lives; reach the top and she's saved. Hi-score persists between runs. Left/Right run along the girder, Up/Down climb ladders, Z to jump (and to restart).

Dr. Mario puzzle

A virus-busting pill puzzler. The doctor drops two-color capsules into a bottle crawling with red, blue, and yellow viruses — steer them down, twist them around, and line up four or more of one color across or down to wipe them out. Every clear flashes white and kicks the screen; loose capsule-halves rain down afterward and can chain into bigger combos with a rising arpeggio. Empty the bottle of every virus to beat the level and seed a tougher one; choke the neck and you top out. Best score is saved. Left/Right move, Up rotates, Down soft-drops, Z/X start the next level or restart.

Dwarffort simulation

A pocket-sized Dwarf Fortress: a top-down colony base-builder on one screen where you never steer a dwarf — you designate the work. Drag over solid rock to mark it for digging (mining hews stone) or over open floor to queue a wall (a dwarf hauls a block and raises it), and a handful of stubby, helmeted dwarves A*-path to the nearest reachable job, swing their picks through puffs of dust, and build out the corridors you carve while a day clock ticks toward day 12. Pickaxe taps ride a euclidean rhythm over a slow cavern bed, the stone counter rolls, and a new-day bell eases a banner across the cave. Left-drag to designate with the current tool, right-drag to erase; 1 = DIG, 2 = WALL; SPACE pauses; reach day 12 and the fortress endures — click to found a new fort.

flyover

A third-person flight sim over a procedurally generated earth — three engine tricks fused into one sky. The ground is REAL 3-D voxel-space terrain: a noise heightmap ray-marched per column, front-to-back, with a y-buffer and hillshading, so you fly over, around and into actual hills, ridges and snow-capped peaks (sea, beach, grass, forest, rock, snow). Forests and whole cities of windowed buildings are billboards that stand on the terrain, projected far-to-near; clouds are billboards lifted into the sky. Your low-poly plane is a flat-shaded solid-3D model pinned to the foreground — it banks when you turn, pitches when you climb, and casts a dithered shadow on the ground. The world is a vast 8192×8192 continent with ~90 named towns dotting the coast — each a gradient from tall downtown towers out through low suburban houses with gardens to scattered rural farmsteads (barns, farmhouses, silos) and patchwork fields stamped onto the grassland. A scrolling, player-centred minimap shows the land around you, nearby town names, and your heading (props are spatial-gridded so only the ones near you are ever drawn). You can land, take off, and crash: set down in an open field at low speed, taxi, and lift off again — or fly into a tower, a peak or the sea and go up in a fireball (press Z to restart). Sandbox controls: Left/Right turn (the plane banks into it), flight-stick pitch (UP noses down/descends, DOWN climbs — hold UP low and slow to land), Z/X throttle.

Fonts

Showcases the three built-in fonts (FONT_NORMAL 8×8, FONT_SMALL 4×6, FONT_TINY 3×5), print_shadow, print_outline, and the chained print return value.

Football Manager sports

An FC-Mobile-style manager mode played as a three-season CLIMB: you take Feyenoord from the regional EERSTE DIVISIE up through the EREDIVISIE (the best Dutch clubs) and into the CHAMPIONS LEAGUE (the giants of Europe). Each tier is its own 12-club, 10-round league; finish 1st to be promoted, and win the Champions League to be crowned CHAMPION OF EUROPE. Miss out and you replay the tier — but your squad and cash carry over, so the long, scrollable transfer market (a 30-deep shortlist of real 2026-era stars, the world-class names carrying 90+ ratings at a premium price — Yamal, Mbappe, Haaland, Courtois) is how you bankroll the climb. Run your XI on a drag-to-arrange formation pitch with a bench of spares, switchable 4-4-2 / 4-3-3 shapes and an out-of-position penalty. Before each match a SCOUT REPORT previews the next opponent — their style (attacking / defensive / balanced), strength and danger man — and your formation counters their style (park the bus vs attackers, go wide vs a low block), so you can reshape the side before you KICK OFF. Fielded players can pick up INJURIES that sideline them for a few rounds (unfieldable and worth less), forcing you to reshuffle. Hit kick off and the engine auto-sims a scoreline from your strength versus the opponent's, ticking goals up on a scoreboard before slamming home WIN/DRAW/DEFEAT while the table re-sorts live on points and goal difference. Player names are pooled by position, and the HUD, market and standings use the compact 4×6 font to fit the bigger rosters. Drag players between pitch and bench (hover a chip to see the player's name + rating), click 4-4-2 / 4-3-3 to switch shape, click a price to BUY or a value to SELL, and click PLAY MATCH (TAB cycles SQUAD/MARKET/LEAGUE, ENTER plays).

Hangman word

The classic word-guessing game, drawn entirely from primitives — no sprite sheet. A hidden word waits as a row of underscored blanks; guess a letter and right answers pop into place with a green flash and a rising chime, while every wrong letter burns a guess and adds the next body part to the gallows: head, torso, two arms, two legs, then a red-X-eyed hanging. Win by completing the word before six misses; the figure drops in with a little ease and the screen shakes on a bad guess. Tracks your session win count and current streak across runs. Type a letter (A-Z) to guess, or click a key on the on-screen alphabet; press ENTER or click to deal a fresh word after a win or loss.

Infiniminer sandbox

A pocket-sized proto-Minecraft: a 16x16x6 voxel world you stroll through in first person, mouse-look swinging a white crosshair across tritex-textured cubes of grass, dirt, stone and wood. Painter-sorted, back-face- and hidden-face-culled cubes with per-face dither shading give it that picoCAD/PS1 glow; a DDA raycast from screen-center finds the block you face and outlines it in blinking yellow. Left-click mines it out, right-click stacks your held block against the face you aim at, each with a filtered pluck pitched to the material. A tiny hill and a couple of trees give you somewhere to start digging. Calm, tactile, goalless. Controls: WASD move, mouse look, left-click mine, right-click place, 1-4 pick grass/dirt/stone/wood, R regenerate the world.

Jumpstar platformer

An endless vertical jumper in the Doodle-Jump grain: a little astronaut auto-bounces forever off procedurally spawned platforms while you steer to keep landing on the next ledge up. Green platforms are solid, blue ones slide and bounce at the edges, and cracked brown ones crumble away after a single bounce, so dawdling drops you. Grab bobbing stars for a sparkly bonus, ride the climbing camera through a parallax starfield, and don't fall off the bottom — every landing squashes the astronaut, shatters fling debris, and the screen kicks on a break. Height is your score and your best run is saved between sessions. Steer with A/D or Left/Right (wraps at the screen edges); jumping is automatic; press Z to jump again after a fall.

Klondike Solitaire tabletop

The patience classic on green felt. Seven tableau piles cascade in alternating-color descending runs, a face-down stock deals one card at a time to the waste, and four suit foundations build home from Ace to King. Grab a single card or a whole valid run and it lifts under your cursor with a soft drop shadow; drop it on a legal pile or a foundation and it snaps in with a chime, while the newly exposed tableau card flips itself. Clear all four suits to win — the felt darkens, a banner drops, and your running tally of games won is saved. Cards are hand-drawn from primitives (no sprite sheet) with pip suits and crisp white faces. Controls: click the stock to deal one card to the waste (click the empty stock to recycle the waste); drag a card or run between tableau piles or onto a foundation, invalid drops snap back; press R or click the win banner to deal a fresh shuffle.

Leisure Suit Larry adventure

A sleazy-lounge point-and-click in the Sierra tradition, played for groans. You're Larry Laffer — polyester suit, gold medallion, hopeful mustache — at the neon-lit Lucky Lips Lounge, out to charm Roxy the cocktail waitress into a date. She's heard every line, so you'll need to swipe the right props and pick the right words: TAKE the rose off the bar, USE the MUSK MAGNET cologne dispenser, feed the jukebox a borrowed quarter, then sashay to the back booth and TALK your way through a menu of pickup lines. Most earn a withering eye-roll (or a full-on SLAP that shakes the screen); arrive holding both props and pick the genuinely smooth line and the candlelit night is yours. Built on the SCUMM verb/inventory scene engine across two velvet rooms, with cheeky PG-13 innuendo only. Mouse only: click a verb (Look/Use/Take/Talk), then a hotspot to act or the floor to walk; click an inventory slot to hold an item then a hotspot to use it; click a dialogue line in the booth; click to play again.

Lemmings puzzle

A one-screen tribute to DMA Design's 1991 classic. A trapdoor drops a stream of brainless green-haired lemmings that trudge right, fall off ledges, splat in the lava pit, and turn at walls with zero self-preservation. The terrain IS the physics: a destructible pixel buffer where diggers and bashers erase dirt and collision just reads it back. Arm a job from the bottom toolbar then click a lemming to assign it — DIG straight down, BUILD a diagonal bridge, BLOCK as a living wall that turns the herd around, or BASH sideways through dirt — and steer enough of them into the glowing HOME exit before you run out. Save 10 of 20 to win. Controls: click a job tile in the bottom bar to arm it, click on a lemming to assign the armed job, right-click or click the armed tile again to disarm, R to restart.

Lil Farm simulation

A pocket Harvest-Moon day loop on one screen: walk your little plot, swap between hoe, seed pouch and watering can, and work the soil — till grass into furrows, plant a seed, splash it wet. Watered crops climb a growth stage every morning you sleep, ripening into bobbing red harvests you scoop into your bag, haul to the sell bin for gold, and spend on fresh seeds at the shop. An energy bar drains with every swing and a sun arcs across a sky that warms from peach dawn to dusk purple; sleep in the bed to bank your growth and roll to the next day, or run the clock out and pass out cold. WASD/arrows walk, 1/2/3 pick hoe/seed/can, Z use tool or interact (bed sleep, bin sell, shop buy), X sleep-or-sell, C buy a seed.

Lode Runner platformer

A pocket-sized Lode Runner: sprint a chunky runner across a brick-and-ladder maze, scoop up every glinting chunk of gold, then climb the exit ladder that lights up only once the level is clean. A red guard hunts you on the same rules you obey — run, climb, hang hand-over-hand from ropes, and fall. Caught on open ground and you're done, so dig: Z chews a hole in the floor down-and-left, X down-and-right, dropping the guard into a pit that refills a moment later and crushes anything still stuck. Two single-screen levels, drawn entirely from primitives, with a clean clear/death/restart loop and a saved best. Arrows run/climb/rope, Z dig-left, X dig-right, R restart.

Marble Madness arcade

Roll a chrome marble down three isometric plateaus to the blinking GOAL before the 30-second clock runs out — then RACE YOUR GHOST: every winning run that sets a new best time is recorded (a position stream, saved between sessions) and replays as a see-through blue marble rolling that exact run alongside you. Real momentum physics: arrows only nudge, gravity does the rest. Ramps are the only way UP a ledge; rolling OFF one gives real airtime — the speedrun tech: a one-unit drop on the east side skips the second ramp, but overshoot it and you fly off the open edge into the void. Acid kills, checkpoints bank progress, a filtered rumble rises with your speed, and a landing thump + screen kick sell every drop. Arrows roll the marble (relative to the iso view); Z or Enter restarts.

Merchant tycoon

Age-of-sail buy-low/sell-high trading sim: 4 ports, 6 goods, daily price drift, shortages/gluts, storms & pirates, a ticking debt and a 40-day clock. MOUSE: click a good to BUY 1, right-click SELL 1; bottom bar BUY/SELL/QTY/DEBT/SET SAIL; click a port on the chart to sail. KEYS: up/down pick a good, Z buy / X sell, Q cycle qty, D moneylender, M or ENTER open the chart (left/right pick port, ENTER sails).

Minesweeper puzzle

The desktop classic, rebuilt from scratch on the fantasy console. A 16x14 field of beveled tiles hides 30 mines; left-click reveals, and uncovering an empty cell triggers a satisfying flood-fill cascade that opens its whole region in one click. Numbers 1-8 glow in the canonical colors to count adjacent mines; right-click plants a flag. The first click is always safe — mines are seeded only after you commit. A live mine counter and a running timer flank a smiley face that grins, dies, or beams depending on your fate; clearing the board logs your best time. Tap a mine and the whole field detonates with a screen-shaking boom. Left-click reveals, right-click flags, click the face or press R for a new game.

Missile Command shooter

ICBMs streak down a night sky in long glowing diagonals, each one falling toward one of your six cities. You command three batteries with limited ammo per wave; aim the crosshair and click, and a counter-missile launches from the nearest battery with shells to spare, races to the cursor, and blooms into an expanding ring that vaporizes any warhead it touches — chain-detonating into more rings as it goes. Survive the wave to refill ammo and bank a bonus for every city and shell left standing; each wave throws more missiles, faster. When the last city falls it's the end. Mouse to aim, left-click to fire from the nearest battery, click or SPACE to defend again.

Monkey Island adventure

A bite-size SCUMM point-and-click on the docks of Mêlée Island, in the spirit of The Secret of Monkey Island. Pick a verb (Look / Talk / Use / Take), click a hotspot, walk over and act: grab the rusty cutlass off a crate, read the notice board, eye the moored ship. Talk to the Sword Master through a branching dialogue tree until she challenges you to the signature insult sword-fight — a turn-based war of WORDS where she hurls an insult and you must click the one comeback that actually answers it (then press your own attack while she sometimes flubs hers). Land three exchanges to win and earn the title of pirate; clang a wrong line and the screen shakes red. Controls: mouse picks a verb then a hotspot; click the floor to walk, click an inventory item to hold then a hotspot to use it; in conversation and in the duel click a line or press its number (1-4); SPACE/ESC clears a message, click to duel again on the end card.

Othello tabletop

Reversi on a felt 8x8 board: you are black, the CPU is white. Drop a disc only where it flanks a straight line of the opponent and every captured line turns over, the flip travelling outward from your new disc as a squashed-oval roll that glints green through the seam. Legal squares pulse, the score rolls live in the HUD, corners trigger a chord and a screen kick, and a side passes when it has no move; the game ends when the board fills or both pass. The CPU plays a greedy, corner-weighted heuristic that hoards corners and shuns the squares beside them. Drawn entirely from primitives, no sprite sheet. Mouse: click a glowing square to place. Keyboard: arrows/WASD move a cursor, Z/ENTER places; click or Z on the banner for a new game.

Physics playground

A tiny verlet physics world you can read end to end — the whole engine is three ideas: a point remembers where it was last frame (so velocity is just now-minus-last), a stick keeps two points a fixed distance apart, and each frame you move every point then relax the sticks a few times. From those two primitives the cart builds a whole showcase: a dangling chain, a draping cloth sheet, a wobbly soft-body blob (a ring of points around a hub), pseudo-solid boxes and a triangle that stack and tumble, and bouncy balls — all colliding as circles and against each other's edges. Left/Right change the substep count live (more substeps = fast/heavy things stop tunnelling through thin surfaces). Drag any point to grab and throw it; Z drops a ball, X drops a box, R resets.

Pool sports

Rack 'em up: 8-ball-style billiards on one green table, two players hotseat. Fifteen colored balls and a cue ball obey honest 2D physics — equal-mass elastic collisions clack balls off each other, rails bounce with restitution, and rolling friction lets the whole table coast to a stop on its own. Aim the cue with the mouse along a dotted guide that stops at the first rail, sink object balls into the six pockets to score (pot one and you shoot again), and watch out for the scratch when the cue ball drops. Soft synth clicks, rail thunks, pocket drops and a break crack sell every contact. Clear the felt to win. MOUSE to aim, HOLD the left button to charge power then RELEASE to strike, RIGHT-CLICK or SPACE to cancel a charge, R to rack a fresh game.

Puyo puzzle

Drop pairs of colorful blobs into a narrow well, sliding and rotating them as they fall. Connect four or more of the same color and they pop in a flash of sparks — and when the collapsing stack lands into another match, it pops too, igniting a CHAIN that climbs in pitch and score the longer it runs. Chains are the whole game: a clean 5-chain rings out like a fanfare and sends the screen shaking. Stack to the top and it's over; your best score and longest chain are saved. Left/Right move, Up or Z rotate, Down soft-drop, Z to restart.

Q*bert arcade

Hop the pyramid. A 28-cube isometric pyramid floats in a starry void, every cube drawn from pure primitives as a shaded diamond with two side faces. You're a fuzzy orange critter who hops diagonally cube to cube, each landing flipping the top from blue to gold with a square-wave boop — paint all 28 to clear the board and climb to the next pyramid. Miss the edge and you plummet off into black; a purple snake named Coily hatches and bounces down after you, and one touch costs a life. Smooth eased hop arcs, screen shake on death, a victory chord on clear, three lives, and a saved hi-score. Controls: Q/E hop Up-Left/Up-Right, A/D hop Down-Left/Down-Right (arrows mapped diagonally as a fallback), Z or ENTER to restart after game over.

Ragdoll

Three tiny Verlet-physics stick figures that struggle to stay upright — connected points, distance constraints, and gravity. Drag any limb to grab and throw: while held a character goes fully limp, and the moment its feet touch the ground again it straightens back up. Z drops a rolling ball at the mouse, X spawns a new character from the sky, R resets the scene.

rasterizer test

A renderer pixel-accuracy test bench, not a game — it proves every fill primitive's outline lands exactly on its fill boundary. Four pages of shapes (curved: circ/oval/rect/rrect; polygons: tri/quad/ngon/star; arcs: arcfill/ring/thickline; plus an equivalence self-test), each drawn as a white fill with a red outline. Press SPACE to analyse: it reads the canvas back with pget and flags any outline pixel buried inside the fill (pink) or any fill edge the outline failed to cover (yellow), reporting a live mismatch count that should read 0. Z toggles outlines, X toggles dither fill, C cycles pages.

Rollswarm sandbox

Katamari x boids: roll a growing ball through a panicking flock that bolts harder the closer you get, swallowing any critter smaller than you to snowball toward the size goal before time runs out. WASD/arrows to roll, Z to replay.

Sand Burrow arcade

A whole cave of live falling-sand: dig tunnels and the sand above pours down to refill them — grab every gem and reach the exit before a collapsing column buries you. A/D or arrows walk + dig sideways, W/up climb + dig up, S/down dig straight down, Z/X/R restart.

Shapes

Showcases the geometry helpers: ngon/ngonfill (rotating polygons), star/starfill (badges and sparkles), poly/polyfill (custom outlines), thickline, rrect/rrectfill (panels and bubbles), vgradient/hgradient. Includes a fillp-dithered hexagon.

Street Fighter fighting

A 1-on-1 versus fighter on a dusk rooftop stage — you against a pushy, reactive CPU, with health bars up top, a round clock ticking between you, and a best-of-three. Each stick-fighter is a little state machine: walk in and out, jump, crouch, hold back to BLOCK, and throw a fast LIGHT, a heavy KNOCKBACK swing, or a quarter-circle-forward FIREBALL. Attacks have real startup/active/recovery, so spacing and timing decide everything; hits land with screen shake, a white hit-flash, a couple of frozen impact frames, and chip damage on block. The CPU reads the gap and blocks your swings, whiff-punishes your recovery, jumps in, and zones with fireballs — and gets tougher each round you take. Win the match to grow your saved win streak. Controls: A/D walk, W jump, S crouch, hold back to block, Z light, X heavy, down then forward + Z for a fireball, Z to rematch.

Strip Poker tabletop

A velvet after-hours lounge where you play heads-up five-card draw against Sable, your silhouette sweetheart. Ante up, click cards to HOLD, then DRAW and choose to BET, CALL, or FOLD; at showdown the best hand takes the pot. Win and the cheeky REVEAL meter lights a notch — fill it and Sable strikes a coy new pose, blows a kiss, and the flirtation escalates a tier (TEASE to SCANDALOUS); lose and the meter slips. Strictly PG-13: soft spotlit silhouettes, a fluttering feather boa, a wink, and double-entendre banter over a slow sultry lounge bass. Mouse: click your cards to HOLD, click BET / CALL / FOLD, click DEAL to start a hand and advance the title / game over. Keys: arrows pick a card, Z hold, B bet, C call, F fold, SPACE or ENTER deal & advance.

Summer Games sports

Button-mash track and field in the Track & Field arcade lineage: pick an event off a sunlit stadium menu, then hammer two keys to build raw speed and nail one clutch press. TWO events on a shared event-shell — 100M SPRINT (mash Z/X to sprint, then dip at the tape with a timed LEAN) and LONG JUMP (mash the runway, then stab JUMP at the best takeoff angle on a sweeping needle — overrun the foul board and it's a SCRATCH). A scoreboard panel tracks your personal best per event, saved between runs, with crowd-roar swells, footfall ticks pitched to your speed, dust off the feet, screen shake and a fanfare on a new record. Menu: Up/Down choose, Z start. In an event: alternate Z and X to run, press UP to lean/jump, X or ESC backs out.

Swarmturf sandbox

Splatoon x boids: you steer a flock that PAINTS the ground it flies over, carving turf out of a rival swarm's color. Hold LEFT-CLICK (or WASD) to pull your swarm toward the cursor; most painted ground when the timer runs out wins. Click / Z to replay.

The Incredible Machine puzzle

A gravity-physics puzzle sandbox in the spirit of The Incredible Machine: a red ball must fall into the GOAL bucket, and it's on you to build the contraption. Drag ramps, see-saws, fans, walls and spare bumper-balls out of the parts tray onto the board, then hit RUN and watch gravity take over — the ball reflects off your bars pinball-style, fans blow it upward in animated wind arcs, see-saws tip toward the weight, and hard bounces spark particles and ding the synth. Two hand-built levels with fixed pegs and ledges; solve both for the victory screen. Left-drag parts from the tray onto the board (right-click a placed part to lift it), R to run / reset the ball, C to clear the board.

Transport Tycoon tycoon

A pocket-sized Transport Tycoon. Two towns sit on a green tile world split by a wandering river; you lay a rail line by hand, one tile at a time, growing track out from town A until it reaches town B. The moment the line connects, town A starts stockpiling cargo and a chuffing little locomotive is yours to dispatch — it rolls A to B hauling goods, pays cash on delivery (the balance rolls up with a cha-ching and a coin pop), then runs back empty to wait for the next run. Build it, then watch it earn until you hit the tycoon goal. Left-click a grass tile next to your rail's end (or town A) to lay rail, left-click a town to dispatch the idle train, R for a new map.

Wildfire arcade

The doom-fire propagation rule turned into a chasing hazard — outrun a top-down floor fire that spreads cell-to-cell and burns through walls to reach the green exit. WASD/arrows move, Z/A dashes (short cooldown), R/X instant-retry.

Winter Games sports

An Epyx-style winter meet built on a clean, reusable event shell — pick your nation, then work down a scoreboard of skill events one at a time, with bests saved between runs. SKI JUMP is two-phase: ride the in-run and stab Z to fire the takeoff on a sweeping power meter, then balance your lean in the air (Up=back, Down=forward) — keep the form gauge centered for distance, over-rotate and you tumble down the slope. SPEED SKATING is an alternating-key rhythm: tap Z, X, Z, X in a steady cadence to push each skate while holding your lane around the ice oval — mash one key and you stumble, hit the rail and you bleed speed. Snow drifts on a noise wind, a synth whoosh rides the launch, skate strides click on the beat, and a medal ceremony crowns your total. Controls: Title — Left/Right pick nation, Z start; Scoreboard — Up/Down choose, Z enter, X title; Ski Jump — Z run then Z takeoff, Up/Down lean; Speed Skating — alternate Z/X, Up/Down hold lane; Z returns to the scoreboard after each event.

Wordle word

The daily word puzzle, distilled to its purest loop. A hidden five-letter word waits behind six empty rows; type a guess and watch the five tiles flip one-by-one — green for a letter in the right spot, orange for one that's in the word but misplaced, gray for absent — with the proper duplicate-letter rule so repeated letters score honestly. A live on-screen QWERTY keyboard repaints each key to the best news it has earned, an invalid or short guess buzzes and shakes the board, and a solve sets the winning row bouncing over a rising arpeggio while a loss reveals the answer. Your win streak persists between runs. Type A-Z to fill the row, BACKSPACE to delete, ENTER to submit (or click the on-screen keyboard, including its ENT and DEL pads); ENTER on the result screen plays a fresh word.

Worms tactics

A 2-player turn-based artillery duel on fully destructible pixel terrain — the genre Gorillas only half-shipped. Two worms perch on a rolling noise-generated landscape; on your turn you walk along the ground, sweep your bazooka's aim, then hold to charge a swinging power meter and release to fire. The rocket arcs under gravity and a live wind that actually bends the shot, then blows a real crater into the ground (carved pixel by pixel) and damages anyone in the blast — worms even tumble when the dirt under them is gone. First to knock the other's HP to zero wins. P1 LEFT/RIGHT walk, UP/DOWN aim, hold SPACE to charge power and release to fire; SPACE to restart after a win.

Zak McKracken adventure

A SCUMM-style point-and-click caper: you're tabloid reporter Zak, woken by a phone tip that your plane ticket is locked in your desk. Three hand-drawn rooms — a moody SF apartment with a ringing phone and a fishbowl, a hallway with a stuck vending machine and a fire-axe, and a night cab to the airport — wired into a real scene engine with a four-verb bar, a hover-labeled hotspot grammar, an inventory strip, and walk-to-floor navigation. Solve the one combination puzzle (take the paperclip, USE it to bend a lockpick, pick the drawer, grab the ticket) to unlock the cab and win. Mouse: click a verb (Look/Use/Take/Talk) then a hotspot; click the floor to walk; click an inventory item to hold it, then a hotspot to use it; SPACE/ESC clears a message.

advance wars tactics

A bright turn-based tactics game (an Advance Wars demake), you RED vs the CPU BLUE on one hand-made tile map. The crunch is three systems working together: a unit-vs-unit DAMAGE MATRIX (mechs wreck tanks up close, recon mauls infantry, artillery hits at range 2-3 but can't be countered or move-and-fire), TERRAIN DEFENSE STARS that scale how much a defender soaks (forests and mountains save lives), and CAPTURE — march infantry onto a building to flip it over two turns for income, or take the enemy HQ to win instantly. Factories build new units from your funds, a forecast shows damage before you commit, and every clash kicks a screen-shake, flash, sparks and HP pops. Mouse-primary: click a unit, click a reachable tile (it traces a move arrow over the highlighted range), then pick ATTACK / CAPTURE / WAIT. Keyboard: WASD or arrows move the cursor, Z confirm, X cancel/undo, SPACE ends turn. Win by capturing the enemy HQ or destroying every enemy unit.

arcs

A tour of the arc primitives — arc (part of a circle's rim), arcfill (a filled pie wedge / sector), and ring (a thick radial band). Angles are degrees, 0=right and 90=down like dx/dy. Shows a pie chart, an animated radial cooldown that sweeps and counts %, a chomping pacman, a needle gauge, a fillp-dithered half-dome (fills honor the dither pattern), and a little rainbow of concentric rim arcs. No controls — it just animates.

Arrakis strategy

Dune base-builder: harvesters A*-mine spice for credits, build refineries/power/factories/turrets, queue trikes & tanks vs a CPU faction. Mouse: click/drag select, click to move/attack, BUILD then click to place (1-4 hotkeys). Wipe out the red base to win.

bones

A pixel-man skeleton animator — pose an 18-bone stick figure and flip-book him to life. Each bone is a 1px line set to one of 16 rotations; you author motion in a sequencer grid (bones down the rows, 16 frames across, every cell a hex digit 0-f for that bone's angle) while a live forward-kinematic preview shows the assembled figure — turn the torso and the whole body swings with it. A playhead loops the frames at an adjustable FPS with eased in-betweens, so it moves smoothly despite the 16-step quantization. TAB flips to a RIG view where you set each body part's length AND line width (odd, 1-9px) (left & right share a value) and watch the figure re-proportion live; the whole animation AND its proportions persist via save_bytes, and it opens on a friendly default wave. Arrows move the cell marker (in RIG: pick a part + resize), Z/X turn the selected bone, C copies the previous frame, SPACE plays/stops, [ ] set FPS, - = set the loop length, S/L save/load — or click a cell and mouse-wheel to turn it, or just drag a limb in the preview to pose it directly (snaps to the nearest of 16).

cannon fodder tactics

Top-down run-and-gun squad tactics, mouse-commanded. Lead up to five tiny soldiers across three scrolling battlefields — LEFT-CLICK ground to send the squad there in a loose trailing formation; they AUTO-FIRE their rifles at any enemy in range and line of sight; RIGHT-CLICK lobs an arcing grenade with a big AoE to level the huts and gun-nests that are your objectives. The bittersweet hook: soldiers die PERMANENTLY in a single hit, and the survivors carry between missions and earn promotions (more HP, range and accuracy) — a fallen name goes on the casualty ticker for good. One soldier sprite is pal()-recolored into green squad vs red enemies, and one green tileset is pal()-swapped per biome (jungle, desert, snow). Big fillp+circfill+shake explosions, blood and dirt particles, a grim man-down sting, and a sparse euclid snare bed. Roster persists between runs via save_bytes. LEFT-click move, RIGHT-click grenade, SPACE halt, R restart.

composer (mario paint sound) ⚡2×audio

A melodic music toy in the spirit of Mario Paint's Sound mode. Stamp six cute critters — cat, star, mushroom, note, heart, flower, each its own synth voice (custom ADSR/filter/duty/LFO on slots 5-10) - onto an 11-row x 16-step pitch grid, then hit PLAY and a glowing playhead sweeps the bar singing your tune. Every row snaps to a scale (toggle PENTA/MAJOR) so it always sounds nice; notes squash-pop and flash white as the playhead strikes them. The transport rides the synth's own beat() clock, and your whole song persists between runs via save_bytes(). Mouse: click the grid to stamp the selected critter, click again or right-click to erase, click a critter to pick it; buttons for PLAY/STOP, -/+ tempo, SCALE, CLEAR, SAVE, LOAD. Keys: SPACE play/stop, 1-6 pick critter, C clear, M scale, S save, L load, arrows tempo.

Deluxe Paint

A full pixel-paint program - pencil/line/rect/oval/fill/airbrush/eyedropper/custom-brush/mirror/undo, plus dither PATTERN fills, a Bayer GRADIENT tool, and live COLOR CYCLING (fire/water/rainbow ramps that flow via pal()). Mouse: left=FG, right=BG, click toolbar/palette/patterns, drag for shapes. Keys: b/l/r/o/f/s/i/c/d tools, [ ] size, x swap, m mirror, h hole, u undo.

doom shooter

A Doom-style first-person shooter on the raycaster — stalk a base of corridors blasting charging imps and shooting gunners, drawn as distance-scaled billboard sprites that hide behind walls via a depth buffer. Two weapons (pistol / shotgun), pickups, a red keycard that unlocks the exit, muzzle-flash room lighting and gore. WASD/arrows move + turn, Q/E strafe, Z fire, X (or 1/2) switch weapon, SPACE open doors / hit the exit switch.

druglord tycoon

A Drugwars-style economy game. You have 30 DAYS to flip a small stake — and a loan-shark debt that grows 10%/day — into a fortune, trading six substances across six city districts whose prices swing daily. Buy where a good is cheap, haul it to where it sells dear, stash cash in the bank away from muggers, and pay the debt down before day 30. Travelling to a district costs a day, re-rolls every price, and can trigger an event card: a crackdown that makes a price SOAR, a glut that CRASHES it, a mugging, a cop bust (siren + flashing lights, you ditch your stash), a lucky dumpster find or a bigger coat. Each district is a living tile-map scene — glass-tower downtown, the crate-stacked docks, leafy suburbs, grimy tower blocks, neon Chinatown, the park — with pal()-recolored pedestrians and a day/night sky that re-lights the windows as the days pass. The money counter rolls, prices show green/red arrows and blinking HOT tags, and each place has its own ambient sound bed. Mouse: click a good to buy 1 (right-click sell 1); the bottom bar is BUY/SELL/QTY/BANK/LOAN/TRAVEL; on the city map click a district to travel. Keys: up/down pick a good, Z buy, X sell, Q cycle quantity, M map, ENTER confirm.

dungeon keeper strategy

Be the evil Keeper: carve a dungeon out of solid rock, claim the floor, and fend off the heroes who march in to smash your Dungeon Heart. LEFT-DRAG over rock to designate it for DIGGING - imps A*-path in, mine it out (lifting the fog and exposing buried gold seams), then auto-CLAIM the dug floor and HAUL gold back to the treasury. Spend that gold on three rooms built by dragging on claimed floor: a TREASURY to store gold and pay wages, a LAIR that attracts monsters (and where they sleep to heal), and a TRAINING room where they level up. Unpaid monsters sour and leave. The signature is the SLAP-HAND: click-hold any imp or monster to pick it up and release to slap it down somewhere - rush a digger to a fresh seam or hurl a fighter onto an invader. Five escalating hero waves tunnel in from the gate toward your Heart; your monsters auto-fight and you slap in reinforcements or hit RALLY to call them all home. Torch-lit pal()/fillp dungeon mood, a creepy minor-organ bed with euclidean pick-axe taps, dig-dust, gold sparkle + rollup, combat sparks and a red heart-alarm pulse. Survive all 5 waves to win; lose the Heart and the do-gooders take the land. MOUSE: left-drag dig / build / grab+slap, buttons 1-3 pick a room, 4 or CREATE IMP makes a digger, SPACE/RALLY summons the monsters, right-click cancels.

excitebike racing

Side-view NES motocross with the famous landing-angle skill, an overheat meter, and a track editor. Hit a ramp and you launch into the air with the nose drifting down on its own — hold Up/Down to control the tilt and touch down within a hair of LEVEL to keep your speed; nose-down or tail-down and you wipe out. Hold turbo for more top speed but the temp gauge climbs to a flashing-red redline and a stall, so mud (slow but cooling) becomes a real choice. Race one track against three pal()-recolored CPU rivals you bump past, chasing your best lap (saved). Then switch to BUILD: a mouse editor paints ramps, jumps, whoops and mud onto the lane grid, persisted with save_bytes — save it and test-ride instantly. RACE: Right/Z throttle, X turbo, Up/Down tilt in the air, Left brake. BUILD: 1-5 or click the palette, left-click paint / right-click erase, arrows scroll, S save, Z ride, B title.

final fight fighting

A belt-scroll beat-'em-up — and a reusable brawler engine. Walk a chunky 16×32 hero right through a city; the camera LOCKS into scroll arenas of thugs and a GO arrow releases you on clear, street giving way to a warehouse and a boss. Fighters have x, depth (y) and jump height (z) with y-sort overlap. Tap Z for a 3-hit combo (the third launches a knockdown), X to jump, Z in the air to jump-kick; walk into a thug to grab him then push a direction to THROW him into the others, Z+X for a spin special. Break barrels for food, grab dropped pipes & knives. Enemy variety is all pal() shirt/skin recolors of one sprite set (grunt, knife, bruiser, boss). Hit-stop, shake, white flash, POW stars, slow-mo boss kill, combo counter, and a reactive synth groove. WASD move, Z attack, X jump, Z+X special.

heroes of might & magic strategy

A pocket Heroes of Might & Magic with the whole loop: explore, recruit, build, then DO BATTLE. On the ADVENTURE map your hero spends MOVEMENT POINTS to roam a small continent (terrain costs MP) - click a tile to walk there, scooping gold, ore and treasure chests, flagging the ore MINE for daily income, ducking into YOUR TOWN, or charging the rival. END DAY refreshes movement and advances the enemy hero, who marches on your town - so build an army before he arrives. In TOWN you build up to three creature dwellings (gold + ore) and recruit Pikemen, Archers, Griffins and Ogres into your army, with a fresh batch each new week. The climax is the STACK BATTLE: a unit is one icon labelled with a count (x22) and damage removes whole creatures from it; initiative runs by speed, melee attacks draw RETALIATION, archers shoot at range with no counter, and the hero casts BOLT (damage) or BLESS (buff) - a live damage forecast shows before you commit, with lunges, count pops, sparks and screen-shake. Win the battle or seize the enemy town to win the war; lose your army or your town and it's over. Mouse-primary: click to move/attack, click buttons to build/recruit/cast. Keys: SPACE end day, B leave town, Z confirm.

hotline shooter

Top-down, one-hit-kill, instant-retry neon carnage — a Hotline Miami tribute. Storm three building floors of rooms (a real tile map() of walls and kickable doors) and clear every guard: you and every thug die in ONE hit, so it's pure twitch and instant R restarts. Start with a bat, pry pistols/shotguns/uzis off the corpses, and when you run dry THROW the gun to knock a guard down for a free melee finish. Burst a door with SPACE and the guard behind it goes down. Enemies patrol with LOS vision cones, hear your gunshots and come investigate, and telegraph before they fire. Chain kills fast for a popping score multiplier. The juice is the game: hot neon palette (pal()-tinted per floor), screen-shake + white flash + hit-stop on every kill, slow-mo on a room's last kill, blood pools that stain the floor, brass casings and gibs - over a driving synthwave bed (LFO-swept filtered saw bass, square arp, four-on-the-floor drums, bass-drop sting on clear). One body sprite recolored into player/thug/guard via the crowd.c pal() trick. WASD move, mouse aim, LEFT-CLICK attack/fire, RIGHT-CLICK or Q throw your gun, SPACE kick a door, walk over a dropped weapon to grab it, R restart.

mass effect rpg

A space opera distilled to its loop. Command the SSV Normandy from the bridge: chat with your crew through a paragon/renegade DIALOGUE WHEEL, chart a course on the GALAXY MAP, then drop into a top-down cover-shooter. Move and aim twin-stick while two AI squadmates flank and fire; duck beside crates and walls that genuinely block bullets AND line-of-sight (real cover), regen your shield between firefights, and unleash a biotic blast that slows time and flings the swarm. Clear the husk waves, then break the Reaper Core. The crowd-cart trick runs the whole cast — ONE fighter sprite, recoloured with pal() into the hero, both squadmates and every enemy — and each planet is its own tile theme. A final wheel choice (spare / disable / execute), weighed against the morality you built on the bridge, forks the ending. HUB/MAP/DIALOGUE: mouse + Z (X backs out of the map). MISSION: WASD move, mouse aim, Z or left-click fire, X biotic blast.

neon rain adventure

A noir point-and-click murder case. Work one rain-soaked night across five hand-painted scenes - flat, bar, alley, office - hunting the killer of singer Mara Vance. Hover hotspots to LOOK/TAKE/TALK/GO, collect evidence, grill two suspects through branching dialogue, fill your case notebook, then name the killer. Heavy pal() neon lighting, fillp() fog + wet-street reflections, a rain particle pool, and a slow synth bed (lowpass pad, vibrato sax, a sting on the reveal). MOUSE: act / click a held item onto a hotspot. RIGHT-CLICK: drop item. N: notebook. Z or click: advance text.

operation wolf shooter

An on-rails light-gun shooter, mouse to the core. The world scrolls past on a rail — one tile map() recolored per stage with pal() (jungle, enemy camp, airfield) — while soldiers rise from the treeline, telegraph with a raised rifle, then loose bullets and lobbed grenades that come AT the screen; shoot them out of the air. LEFT mouse is the magazine machine gun, RIGHT is the scarce rocket, and you RELOAD by shooting the drifting supply crates. Don't gun down the hands-up civilians — it costs health and score. Wave-based across three stages with a health bar (no lives), best score saved. Muzzle flash, recoil, brass casings, tracer, white hit-flash, fillp explosion rings, screen shake, a damage flash and a low-health alarm. Move mouse to aim, LEFT shoot, RIGHT rocket, shoot a crate to reload.

outrun racing

A sun-drenched pseudo-3D arcade racer with BRANCHING roads. Blast down a curving, hilly highway faked from projected triangles, weave through traffic (each car packed with little passengers), and beat each checkpoint before the clock runs out. The twist: at every checkpoint the road SPLITS into two diverging ribbons with a grass island between them — steer onto the left or right fork to choose your next biome, and the scenery ahead recolours to the road you're leaning toward. Five biomes (coast, desert, city, forest, alpine) share one procedural road via pal() recolour; the stages are a binary TREE generated on the fly, so no two runs take the same path. Clip a car and you spin out for a time-costing tumble; off-road bogs you down in a cloud of dust. Engine pitch tracks your speed, tyres screech through hard corners, speed-lines streak past flat out. Reach the goal stage to win. Z / Up: gas — X / Down: brake — Left/Right: steer (and pick a fork).

pinball tabletop

A hand-built physical pinball table — gravity, a steel ball that reflects off line-segment walls, swinging flippers with real tip-snap, pop bumpers, slingshots, a DREAM drop-target bank that arms MULTIBALL, a spinner and an orbit multiplier. Z/←/A = left flipper, X/→/D = right, hold ↓ or SPACE to charge the plunger then release to launch, ↑ to nudge (careful — TILT!), SPACE to play/retry.

pizza tycoon tycoon

Build a pizza empire across six districts with their own foot-traffic, rent and TASTE — each loves one topping and loathes another. Tune each shop's recipe on a live pizza you top slice-by-slice, set the price to the volume-vs-margin sweet spot, then hit NEXT DAY and read the ledger. A rival magnate keeps buying shops and undercutting you; shady MAFIA JOBS offer fast cash for rising HEAT (skip the protection money and a shop gets torched). pal()-recolored crowds, a day/night tint sweep, a jaunty cafe bed and an ominous mafia sting. Out-earn the rival by day 20. MOUSE: click a district (yours opens MANAGE, a free one shows BUY); toggle toppings, [-]/[+] or wheel for price, NEXT DAY to advance, ACCEPT/DECLINE the cards. KEYS: arrows pick, Z buy/manage, ENTER next day, 1-6 toppings, M back.

pod racer racing

Twin-engine pods screaming through a textured rock chasm — and NOT a flat scanline road. It clads the whole canyon in real tritex geometry: the ground is a tech-floor that stretches to the horizon and the walls are rock strata rising on both sides, drawn far→near as a painter's pass (short segments keep the affine warp small, like textured3d's subdivision). The one deep mechanic is BOOST/HEAT — hold A for massive speed while engine heat climbs to a blowout stall; vents cool you off-boost, so it's pure risk/reward. Scrape a wall and you shed speed in a shower of sparks. A layered detuned engine drone pitches with speed, the boost adds a filter-swept roar (FILTER_LOW + LFO_CUTOFF) and a rising overheat alarm, with an FOV-pulse, speed lines, screen-shake and a sonic-boom flash at top speed. Race 3 laps against 4 CPU pods, best lap saved. Up/Z throttle, Down/X air-brake, Left/Right steer, hold A (or Shift) to BOOST.

river city fighting

A procedural belt-scroll brawler-RPG. Fight your way through four re-rolled gangs across downtown, the park, the mall and the docks, scoop the coins they drop, and spend them at the diner on stats (HP/STR/DEF/STAMINA), a heal, and new moves — a spin special and a dash. The whole cast is one 16x32 sprite set recolored per-gang with pal(); floors are tile maps rebuilt per zone; combat has hitstop, shake, flash, combos and a depth-based hit rule. Beat the docks boss to clear the city. Arrows move (up/down = depth), Z attack (tap x3 combo / air = jump kick), X jump, down+Z spin special, double-tap to dash. Diner: up/down pick, Z buy, X leave.

sensible soccer sports

Top-down arcade footy down a vertically-scrolling pitch, 6-a-side. The headline is AFTER-TOUCH: kick the ball, then HOLD a direction while it's in flight and it bends in the air — banana shots that curl round the keeper, just like the Amiga classic. You always control the team-mate nearest the ball (it auto-switches, with a ring to show who); the CPU steers your other five plus the whole opposing team. The mow-striped pitch is a real tile map() with primitive markings and goals, the camera follows the ball, and both kits + keepers come from ONE tiny player sprite recoloured per-team with pal() (the crowd-cart magic-colour trick). Ball shadow that lifts on lobs, net-ripple + screen-shake + a crowd roar on goals, a ref whistle, and a crowd bed that swells as play nears a goal. Two 90s halves with a half-time end-swap, win/lose/draw, best result saved. D-pad run, Z kick/tackle, then hold to bend.

sky strike shooter

A vertical-scrolling shoot-em-up (Raiden / 1943 / Tyrian), built around its weapon-upgrade loop. Your fighter hugs the bottom while a tile map() of sea, islands and an airbase scrolls down past you and waves of enemy craft pour in from the top. Shoot down P pods to climb your main gun L1->L5 (single -> twin -> 3-way -> 4-way -> 5-way spread), then keep grabbing them to bolt on side OPTION wingmen that mirror your fire; B pods stock a screen-clearing bomb that wipes every bullet in a white flash. Six foes off a scripted, escalating timeline — sine-weaving popcorn flyers, poppers and gunships that aim shots at you, ground turrets riding the scroll — all one sprite each, pal()-recolored into whole squadrons and flashed white when hit, capped by a 3-phase WARLORD boss with a health bar. A tight 1-pixel-core hitbox, X focus mode to thread bullet curtains, particle explosions with screen-shake, hit-stop on the boss kill, a driving chiptune bed and a last-life red alarm. Death drops you one weapon tier, never to zero; hi-score saved. Arrows/WASD fly (8-way), Z bomb (gun autofires), X focus/slow, SPACE or ENTER to start / restart.

smooch lounge arcade

A saucy cabaret rhythm game, all cheeky tone and winks. A pixel-art chanteuse works a velvet speakeasy while hearts and lips fall down four lanes to a sultry lounge groove (walking bass, brushed swing hats, a vibrato-LFO 'voice', a bandpass sax stab) — tap the lane key as each note crosses the hit line for a SMOOCH / SMOOTH / CLUMSY rating, or a wrong-time WHIFF. The clock IS the music: every note rides the beat()/beat_pos() playhead like the drum machine. Good kisses grow a combo multiplier and fill the TEASE meter; fill it for a BIG FINISH where bonus off-beat notes appear, points double, the dancer struts and the pal()-recolored crowd cheers in confetti. 'Blow a kiss' hold notes you keep down for a bonus, lip-print stamps + heart bursts, a buzzing neon marquee, dithered velvet curtains and a swaying spotlight, then a flirty letter grade (STAR OF THE SHOW down to STAGE FRIGHT) with a saved hi-score. Tasteful innuendo, never explicit. A S K L tap the lanes (arrow keys for a gamepad), hold for a long kiss, SPACE to start / encore.

trade winds tycoon

Age-of-sail spice trading across a six-port archipelago. Buy spice, silk, tea, rum, cotton and ivory cheap at their source islands and sell them dear at the home market as prices drift and spike. Sail the sea chart yourself — every voyage costs days and may pitch you into a STORM (steer the wheel to meet the swell or lose cargo and hull) or a PIRATE (a broadside gunnery duel, or gamble a flee on your speed). Spend your gold at the shipyard on a bigger hold, faster hull, more cannons and hull repairs. Build the greatest fortune before the season's 60 days run out — best run is saved. Click a good to buy (right-click sell), the bottom bar for shipyard / set sail, a port on the chart to weigh anchor; keys: arrows pick a good, Z buy / X sell, Q qty, S shipyard, M chart, and in fights Z fires / X flees.

turf war sandbox

Top-down gang-turf takeover: lead your green crew block by block, out-number the rivals holding a district and the whole zone flips to your color with a wash and a chime. Three AI gangs expand into neutral blocks and counter-attack your borders — capture is paper.io/splatoon "presence" applied to a city grid, the crew is the crowd.c pal()-recolor trick (one sprite, four gang colors via a magic shirt index), and a 92 BPM boom-bap bed (filtered bass + euclid hats) rolls under brawl dust, screen shake, a pulsing share-bar and a district mini-map. Own 8 of 12 districts to win; lose your last block and you're wiped out. WASD lead your crew (they follow and break off to brawl), Z for a gang-up melee burst, Z to run it back.

world pointer

Demonstrates the camera + world-space mouse combo. Plant flags in a world 3 screens wide, then SCROLL, ZOOM (mouse wheel) and ROTATE (Q/E) the whole view with camera_ex(x,y,zoom,angle) - and mouse_world_x/y() still lands your clicks exactly on the world, doing the full inverse of scroll+zoom+rotation in one line (a nasty matrix you'd otherwise hand-roll). save_int("most_flags", ...) / load_int() remember your best count by name across runs - no magic slot numbers. Click: plant. Arrows: scroll. Wheel: zoom. Q/E: rotate. X: clear (best stays saved).

xcom (enemy unknown) tactics

Turn-based squad tactics against the alien threat. Move 4 soldiers across a procedurally scattered cover map, take percentage-chance shots with a live hit/crit forecast, duck behind half/full cover (shown as shields), and set OVERWATCH to snap-fire at anything that moves. Fog-of-war hides the battlefield until your soldiers see it; alien pods activate and scatter to cover with an alarm when spotted. Soldiers you name, keep and promote between missions in a light barracks screen — and lose for good if they fall (the roster persists). Mouse: click a soldier, click a tile to move (range shown) or an enemy to open the shot, then FIRE; buttons for OVERWATCH / HUNKER / RELOAD / END TURN. Keyboard: arrows move the cursor, Z act, X cancel, O/H/R actions, E end turn, TAB next soldier. Wipe out every alien to win.

18. particles

The gamedev workhorse: a pool of tiny structs, each with a position, velocity, and a life that ticks down. Move them, age them, recycle the dead ones — and the SAME system becomes a fountain, an explosion, or a puff of smoke just by changing the spawn numbers. Z = explosion, hold X = smoke.

19. juice

The cheap tricks that make a game FEEL good. The same bouncing ball, but every impact fires five classic effects: screen-shake, squash & stretch, a white flash, hit-stop (freeze a few frames for weight), and a puff of dust particles. Press Z to toggle ALL of it off and on so you feel exactly what the juice adds. X to bonk it yourself.

20. effects

A gallery of the visual + game-feel calls: print_scaled (big text), spr_rot (spin a sprite), sspr_ex (scale+rotate+pivot), oval/ovalfill, pal() recolor, shake(), fade(), bar() meters, blink(), and dt() for framerate-independent timing. Z: shake, hold X: fade, hold UP: drain the boost bar.

21. type & save

Keyboard + persistence: text_input() reads typed characters, keyp(KEY_BACKSPACE/KEY_ENTER) handles special keys, and save_bytes()/load_bytes() remember a whole struct between runs — type your name, press ENTER, reopen the cart and it greets you. Also shows text_width() for centering and blink() for the cursor.

22. fill patterns

PICO-8-style fillp: rectfill_pat() tiles a 4x4 bitmask across a rect so two colors make a texture. Shows a dither GRADIENT background, the named patterns (FILL_CHECKER/DOTS/HLINES/VLINES/DIAG/GRID), and a panel that re-rolls a RANDOM 16-bit pattern every second (any value is valid). A: change the color pair.

23. holes & colors

The two sides of fillp(): pass -1 as the hole color and the 1-bits are TRANSPARENT (the scene shows through); pass a palette color and you get an opaque two-tone fill. Same pattern, side by side, over a rainbow so the difference is obvious. Works on rects and circles. A: change pattern.

3D wireframe

Real 3D this time (the raycaster only faked it). A solid is a list of 3D corner points and the edges joining them; each frame rotates every point with sin/cos, projects it to 2D with perspective (far points shrink toward the centre), and connects the dots — the whole 3D pipeline in miniature. Z cycles cube/tetrahedron/octahedron, up/down zoom, left/right spin speed.

A* pathfinding

How a game finds its way around walls. A* always expands the most promising cell, scoring f = g + h: steps taken plus a guess (Manhattan distance) of steps remaining — that guess steers it toward the goal instead of flooding everywhere. Closed cells are explored, open cells are the frontier, yellow is the shortest path. Arrows move the cursor, A toggles a wall, B runs the search or returns to editing.

alley cat platformer

Homage to the 1984 classic. Climb the apartment wall on the window ledges, dodge the birds and the sidewalk dog, and leap into a LIT window. Inside: gobble every mouse before the sweeping broom tosses you out. Nine lives, escalating levels, best score saved. Left/Right: move — Z or Up: jump — (in a room: arrows/WASD to prowl).

boids

A flock with no leader, from three little rules. Each boid watches only nearby neighbours and obeys: separation (steer away from anyone too close), alignment (match the flock heading), cohesion (drift toward the flock centre). Nobody is in charge yet the swarm moves like one organism — emergence. Steer the predator with the arrows and watch the flock part and regroup around it.

bomberman arcade

Battle mode: you (white) versus three AI bombers in a destructible maze of hard pillars and soft crates. Drop bombs that burst after a moment into a cross of flame — it breaks crates (sometimes revealing power-ups), chains other bombs, and kills any bomber it catches, including you. Grab power-ups: B = more bombs at once, F = bigger fire, S = more speed. The AI hunts crates and rivals but flees its own blasts. Last bomber standing wins. Arrows / WASD move, Z or X drops a bomb.

bubble bobble platformer

A tribute to Bubble Bobble. You are Bub, the bubble dragon: run and jump across the platforms, press B to blow a bubble that drifts up and traps a monster, then jump into the trapped monster to POP it into fruit — grab the fruit for points. Clear every monster to advance to the next, tougher wave. Don’t touch a free monster or you lose one of your three lives. LEFT/RIGHT run, A jumps, B blows a bubble.

burger time arcade

Faithful demake of the 1982 arcade classic. You're the chef on a lattice of platforms and ladders. Walk across every segment of a burger ingredient to stomp it down a floor — when all four are stomped it drops, landing on the piece below and knocking THAT one loose too (the cascade), all the way to the plate. Build all four burgers to clear the stage while Mr. Hot Dog, Pickle and Egg chase you. Freeze them with a limited shake of pepper, or drop an ingredient on them for big points. Arrows / WASD: walk + climb — Z or X: pepper.

classic starter (v1 default)

The original cart the editor used to greet you with, kept for posterity. A little explorer strolls a starfield world twice as wide as the screen — the camera follows, a tile floor scrolls past, a clipped minimap tracks you in the corner, and a 2× sspr() portrait sits by the help line. Backed by a jazzy vi-IV-I-V chord loop with a brushed hihat. Shows off camera/follow, map(), sprf() flipping, pget() glow checks, clip(), sspr(), and the timing/chord sound API. WASD move, Z melody note, X strum.

doom fire

The famous 1993 fire effect from one tiny rule. A grid of heat values: the bottom row is always hottest, and each cell copies the heat below it minus a little random cooling, nudged by the wind. No flame is ever drawn — it emerges from the cooling. Hotter values map to hotter colours. Left/right steer the wind, up/down change flame height.

double pendulum

Two rods swinging from each other — and pure chaos. Solving the real equations of motion in tiny steps, the tip traces a glowing trail. The smallest change in the start sends it on a completely different path, which is what chaos means. Z gives a new random start to watch it diverge, X toggles the trail.

dream synth ⚡2×audio

A Minimoog Model D in software (the layout the Behringer Model D clones) — the synth that ties the whole sound engine together. The thing that makes a Minimoog FAT is THREE oscillators stacked and slightly detuned, so every key fires up to FOUR voices on separate instrument slots and the mixer sums them, exactly like the hardware's three VCOs + noise (the mt70 multi-slot trick, zero new engine code). Per oscillator: WAVEFORM (all SIX Model D waves — TRI/SAW/SQR/WIDE/NARW plus SHRK, the triangle-saw 'shark' blend baked as a custom wave with wave_set; wide & narrow pulse are the engine's square at duty 0.30/0.12), OCTAVE (the 32'/16'/8'/4'/2' range switch), DETUNE (the fine-tune knob — the fatness lives here) and LEVEL (the mixer). GLOBAL: a blendable NOISE source (WHITE follows the filter, PINK stays dark), GLIDE (portamento — the mono lead slide), DRIFT (per-voice random detune = analog VCO instability), DRIVE (the Minimoog warmth), KEYBOARD TRACK (the filter cutoff follows pitch — the 1/3·2/3 tracking switches, so high notes stay bright), and hard SYNC (OSC2 synced to OSC1 via instrument_sync/note_sync — sweep the ratio by hand or with a SYNC-targeted LFO for the screaming sync lead). The FILTER is a TYPE × MODE grid: pick the circuit — clean SVF, the real 4-pole Moog LADDER, or the aggressive Steiner-Parker (the Neutron's bite) — then the response LP/HP/BP/NF (the ladder is lowpass-only, like the hardware; SVF and Steiner are full multimode). Plus a filter-contour + pitch ENVELOPE (the Moog 'wow'), the famous draggable ADSR, and THREE LFOs. A PRESET bank (INIT/BASS/LEAD/BRASS/ACID/SYNC) loads factory patches; SAVE stores your own and USER recalls it. Filter, drive, tracking, sync, DETUNE and LEVEL all follow their knobs LIVE under a ringing chord (sweep the detune and the beating shifts in real time); only WAVE, OCTAVE and the ADSR snapshot at the next note. Play it on the on-screen keyboard, the mouse, your computer keys (A row = white, W E T Y U O P = black), or a plugged-in MIDI keyboard. Z/X octave, C/V velocity.

drum machine ⚡2×audio

A 16-step sequencer that shows off the sound synth. Six drum voices (kick, snare, hats, clap, bass), a playhead that sweeps the grid off the beat() clock, and a starter groove built in. WASD move the cursor, Z toggles a cell, X clears, arrow keys change tempo.

elite shooter

Cockpit wireframe dogfight after the 1984 space classic. Pirate ships approach as real 3D wireframes out of the starfield — the world rotates around you as you pitch and yaw, projected to the screen with perspective. Line a ship up in the crosshair and fire your converging lasers. The famous elliptical scanner plots every ship around you, with a stalk showing whether it's above or below. Shields recharge between hits; lose them and you're space dust. Endless waves get tougher as your kill count climbs. Arrows / WASD pitch + yaw, Z fires.

escape the cave adventure

A tiny Sierra-style adventure. Walk with the ARROW KEYS or CLICK where you want to go; stand next to something and press A to look, take or use it. Read the sign, take the rusty key, and open the iron door to escape — three points in all. Watch your step around the pit: this is a Sierra game, after all. Features pop-up narration boxes, an inventory, a score, and a classic death-and-respawn.

falling sand

A powder toy from a handful of per-cell rules. Each cell is one material: sand falls and slides down diagonals so it piles into slopes (and sinks through water), water falls then spreads sideways to find its level, stone never moves. No pile or puddle is ever drawn on purpose — the shapes emerge from grains each making one tiny local decision, the same idea as the fire and ripple carts. WASD move the cursor, hold Z to paint, X cycles material (sand/water/stone/eraser).

filter

A resonant filter sculpts an instrument's tone — instrument_filter(slot, mode, cutoff_hz, resonance). The same buzzy saw through all four modes: FILTER_LOW (warm), FILTER_HIGH (thin), FILTER_BAND (vowel), FILTER_NOTCH (hollow). resonance 0-15 adds a whistly peak at the cutoff, and an LFO on LFO_CUTOFF sweeps the cutoff for a wah. Each panel draws its frequency-response shape with the cutoff line sweeping live, and holds a long note so you hear the filter move. 1-4 select, Z plays the selected one.

fire! arcade

Demake of the 1980 Nintendo Game & Watch. People leap from a burning building — run left/right with the firefighters' rescue net to bounce them across the screen and into the ambulance. Each bounce flings them further right, so you juggle new jumpers off the building while shepherding others along. Miss one and they hit the ground; three misses ends it. Speeds up as you rack up rescues, best score saved. Left/Right or A/D to move the net.

galaga shooter

The formation shooter. Bees, butterflies and bosses fly in and lock into a swaying grid, then peel off to dive and shoot at you. The green Boss can drop a tractor beam — if it catches your ship you lose it, but shoot that boss while it tows your ship and you get it back as a DUAL FIGHTER with double fire. Every 4th wave from stage 3 is a CHALLENGING STAGE: enemies fly through in patterns and can not hurt you — hit as many as you can for a bonus (PERFECT = all 40). Extra ship at score milestones. A/D or arrows move, Z fire.

geometry dash platformer

One-button rhythm runner. You auto-run to the right over a driving beat; tap (or hold) to jump, and the cube flips as it flies. Touch a spike or crash into a block and you explode — instant respawn at the start, with an attempt counter and live progress %. Z / X / Up / arrows / , / . to jump, or tap the screen.

instruments

An instrument is a waveform + an ADSR envelope (+ pulse duty), defined once with instrument() then played like any wave: note(midi, slot, vol). Defines four — PLUCK, PAD, LEAD, STAB — and draws each one's volume-over-time envelope so you can SEE the difference a fast vs slow attack and a short vs long release makes. An arpeggio cycles through all four so you hear them. 1-4 select, Z plays the selected one.

joust arcade

A tribute to the Williams arcade classic. Ride your flying mount over a lava pit: tap A to FLAP against constant gravity, steer with LEFT/RIGHT (you carry momentum), and the screen wraps left to right. Charge enemy riders — whoever is higher at the moment of contact wins; equal height bounces you both apart. A beaten rider drops an egg: grab it for points before it hatches into a fresh enemy. Clear the wave to advance. Three lives; the lava is always fatal.

jungle run platformer

A tribute to Pitfall! (1982). Run through a procedurally generated jungle, jumping rolling logs and open holes, swinging across tar pits on a vine, and grabbing gold before the 2-minute clock runs out — with three lives. LEFT/RIGHT run (walk off a screen edge to reach the next screen), A jumps; in mid-air over a tar pit, A grabs the vine and A again lets go, so time your swing. Each screen is built from its number, so the jungle is the same every visit, just like the original.

katamari sandbox

Roll a sticky ball around a field of junk and swallow everything smaller than you — each thing you eat grows you (by area) and sticks to the ball, until the stuff that used to block you becomes snack too. Soak up as much as you can in 60 seconds. WASD / arrows to roll, Z to replay.

l-system plants

Watch a recursive rule grow into a tree. Start with a tiny string, rewrite every letter over and over (F becomes FF, and so on), then read the result as turtle commands: F draws, +/- turn, and [ ] push/pop a stack to remember and return to each branch fork. That stack IS the recursion. Up/down apply the rule more or fewer times to see detail emerge, left/right bend the angle, Z cycles plants (fern/bush/tree/weed), X toggles the wind.

le petomane ⚡2×audio

A fart synthesizer that is secretly a sound-design lesson. Every rich sound is many simple notes over time: hold the trigger and the cart fires a fast stream of short notes whose pitch slides (BEND) and wobbles (WOBBLE) through a chosen WAVEFORM, fading out at the end — exactly how chip music fakes a glissando. Six knobs and six presets. W/S pick a knob, A/D turn it, Z lets it rip, X cycles presets.

lfo

An LFO is one slow sine wave that wobbles a single knob of an instrument over time — instrument_lfo(slot, dest, rate, depth). Three destinations, one each: LFO_PITCH = vibrato, LFO_VOLUME = tremolo, LFO_DUTY = PWM shimmer (square waves only). Each panel holds a long note on its instrument so you hear the wobble, and animates exactly what's moving — the pitch dot bobbing, the volume bar pumping, the pulse width sweeping. 1-3 select, Z plays the selected one.

lil blob (pet)

A real-time virtual pet, the slow ambient opposite of everything else here. Your blob gets hungry, bored, tired and dirty on its own, poops, can fall sick if neglected, and grows from egg to elder as it ages. Feed/play/wash/sleep/medicine to keep it happy. Saved with save()/load(), so it is still here — same age, same stats — next time you open the cart. Left/Right pick an action, Z to do it.

lil hero (zelda) rpg

A tiny Legend of Zelda. Explore a 3x3 grid of rooms — the screen slides when you step through a doorway — stab enemies with your sword, and at full hearts the sword throws a beam. Octoroks spit rocks, Moblins chase you; killing them drops hearts and rupees. Find the room with the Triforce and grab it. WASD/arrows move, Z sword.

lil life (the sims) simulation

A tiny Sims. Build a house and furnish it, then watch your sim look after itself: five needs (food, energy, bladder, hygiene, fun) decay in real time, and it picks the most urgent one, pathfinds (BFS, around your walls) to the object that fixes it, and uses it. WASD/arrows move the build cursor, Z place, X erase, comma toggles BUILD/LIVE, period cycles furniture.

M.U.L.E. tycoon

One full round of the 1983 economic classic on planet Irata. The whole loop: buy a MULE at the store, outfit it for food / energy / smithore, then race it out to a land plot before it bolts (a runaway timer). Installed MULEs harvest goods based on their terrain, and then you sell your ore in an auction where every sale floods the market and drops the price — so sell while it is high. Supply and demand, made playable. Left/right choose, Z acts, X skips; net worth is scored and your best is saved.

master of orion 4x

A tiny 4X space strategy. A galaxy of star systems: your stars (green) build ships each turn based on their planet's production, and you send fleets to colonise neutral stars (grey) or invade the rival's (red) — send enough to overcome the defenders, who get a defensive edge. An AI empire expands against you at the same time. Turn-based: queue your moves, then end the turn and watch the fleets fly. Conquer every enemy star to win the galaxy; lose all of yours and your empire falls. Arrows pick a star, A selects a source then a target to send all its ships, B ends the turn.

maze generator

Carve a maze, then solve it — two classic algorithms on one screen. A recursive backtracker knocks down walls to random unvisited neighbours and backs up a stack at dead ends, guaranteeing every cell is reachable. Then a breadth-first flood spreads out ring by ring from the start; the moment it touches the exit, the came-from links trace the shortest path. Z builds a fresh maze and animates the carve + solve.

maze maker

Carve a perfect maze, step by step, with two classic algorithms side by side — watch the difference. The BACKTRACKER (randomized depth-first search) dives deep and backtracks off a stack, leaving long winding corridors; PRIM grows outward evenly from a frontier, leaving lots of short dead-ends. Both guarantee exactly one path between any two cells. The current cell glows yellow and the live stack/frontier is highlighted so you can see how each one decides where to go next. Loops forever. A regenerates, B switches algorithm.

micro 4x 4x

A tiny turn-based 4X strategy game (eXplore, eXpand, eXploit, eXterminate), you (blue) versus an AI rival (red) on a fogged tile map. Mouse-driven: click your unit then an adjacent tile to move, or onto an enemy to attack. A Settler founds a city on grass or forest; click a city to spend the gold it earns on Warriors or Settlers. END TURN lets the rival act and collects income. Reveal the map, expand your cities, and wipe out the enemy to win. Each map is freshly generated.

mode 7 racing

The real SNES floor trick: one flat terrain texture sampled once per scanline with a perspective divide, so it stretches to a horizon and rotates under you (not faked road segments). Pilot a craft over a procedurally generated world — sea, beaches, forest, snowy peaks — and fly through the glowing rings (projected with the same math, inverted) before the clock runs out; each ring buys +5s. Left/Right turn, Up/Down throttle, Z climb, X dive.

music garden

A screensaver that plays itself. A gentle chord progression strums under a pentatonic melody that improvises with chance() and a random walk — every note opens a flower that blooms and closes on a sine envelope. Fireflies drift, grass sways, the mood drifts to new keys and colors. Z shifts the mood by hand.

omnichord ⚡2×audio

A tribute to the Suzuki Omnichord (1981) — an electronic autoharp — with a built-in drum machine. Two views toggle from the top bar (or TAB). OMNI: pick a chord from the grid (rows = major/minor/7th, columns = the 12 roots) with the mouse OR the computer keyboard — three rows, one per quality: the top row QWERTYUIOP[] plays major, the home row ASDFGHJKL;'\ plays minor, the bottom row `ZXCVBNM,./ plays 7ths, each key a root from C up — and just like the real Omnichord, holding two keys of the same root gives an extended chord (major+7th = maj7, minor+7th = m7, major+minor = diminished, all three = augmented) — or, on a touchscreen, tap a root then tap the maj7/m7/dim/aug modifier strip (the same extensions in one tap, since two stacked buttons are too close for two fingers on a phone). Then sweep the rainbow SONIC STRINGS strumplate (mouse or finger) to play it as a harp glissando spanning six octaves. RHYTHM: a 16-step drum sequencer (kick/snare/hat/clap, musical noise voices) whose BASS row follows your selected chord root, with preset grooves from the home-organ days — rock, bossa nova, cha-cha, swing, disco, march (keys 1-6 or click). The beat keeps playing while you strum over it; PLAY/STOP (or SPACE) starts it, arrows set tempo. The strings are a soft plucked bell with a warm lowpass.

one-armed bandit tabletop

A slot machine, and a lesson in why you never win. Three reels land on random symbols; match three to get paid. It feels fair, but the RTP (return-to-player) readout drifts below 100% over many spins — that gap is the house edge, and the maths guarantees the machine wins long-term. Credits persist between runs via save/load. Z spins, X takes a loan when broke.

one-hand binary

Count 0 to 31 on a single hand — each finger is a bit worth 16, 8, 4, 2, 1, so any combination is a number and 2^5 = 32 patterns. Exactly how computers count: just on/off. (Yes, 4 is the middle finger all by itself.) Z adds one, X takes one away.

pac-man arcade

The maze classic, ghost AI and all. Eat every dot to clear the board; power pellets turn the ghosts blue so you can gobble them for escalating points. The four ghosts each hunt differently — Blinky chases head-on, Pinky aims four tiles ahead to ambush, Inky flanks using Blinky's position, and Clyde charges until he gets close then loses his nerve. Scatter/chase mode cycling, frightened mode, and eyes that scurry home to respawn. 3 lives, best score saved. Arrows / WASD to steer.

pang arcade

Demake of the 1989 Capcom classic (Buster Bros). Big balls bounce around the arena under gravity. Fire your harpoon-wire straight up and a hit SPLITS a ball into two smaller, faster ones — medium into small, small into tiny, and the tiniest just pop. Clear them all to advance; a ball touching you costs a life. Each size bounces to its own height, so the screen fills with chaos as you break the big ones down. Left/Right move, A or Up fires (up to two wires at once).

paper.io sandbox

Territory capture on a grid. Leave your zone and a trail follows you — loop back to your own color and a flood fill claims everything you enclosed. Cross your OWN trail and you die; cut a rival's trail and THEY die. Three AI rivals expand and cut each other too. First to 60% wins, best run saved. Arrows / WASD to steer (you move on your own).

papers, please simulation

A document-inspection game after Lucas Pope's classic. An applicant hands over a passport (and, on later days, an entry permit); cross-check their fields against the day's posted RULEBOOK and stamp APPROVE or DENY. Catch expired passports, banned nations, missing permits, mismatched names and expired permits — the rules tighten each day, so a clean entrant one day is a denial the next. Five mistakes and you're terminated. A approves, B denies. Glory to Arstotzka.

pathfinding

Watch a search find its way around walls — the SAME loop runs three classic algorithms so you can see the difference. BFS floods evenly in every direction (ignores the goal); GREEDY rushes straight at the goal and gets fooled by walls; A* combines distance-so-far plus an estimate, so it's informed and optimal. Frontier cells glow bright, visited cells fade, the final path lights up yellow, and it re-animates on a loop. Move the cursor and press A to draw/erase walls, B to switch algorithm — and watch it re-solve live.

pixel zoo

The editor's welcome scene — stroll a little zoo and visit the animals. Showcases fillp() dithered fills (the gradient sky, speckled grass, see-through grid fences), spr_rot()/sspr_ex() (a spinning sun, a pinwheel, a vendor's swaying balloons), and the synth: a soft ADSR pad, vibrato birds, and a lowpass-swept lion roar. Each enclosure answers as you walk up to it — water blips at the flamingo pond, the lion roars, the monkeys chatter, the elephant trumpets. The animals are drawn from primitives (ovals, circles, triangles). WASD walk, Z wave.

racer racing

Pseudo-3D arcade racer. A curving road rushes toward you over hills, faked entirely with projected triangles. Dodge traffic, hold the road through the bends, beat your best lap (saved between runs). Up: gas — Down: brake — Left/Right: steer.

raycaster

A Wolfenstein-style first-person maze with no 3D and no sprites — one DDA ray per screen column, drawn as a vertical wall strip with fisheye correction. Walk through a colored grid world with a live minimap. WASD to move and turn, B toggles the map.

ripple tank

Water, and how waves add up. Each cell next height is the average of its neighbours minus its previous height, damped so ripples fade. Drop two stones and the rings cross: crests meeting crests pile up, crests meeting troughs cancel — interference, the same maths behind sound and light. Arrows move the stone, Z drops it, and rain falls on its own.

rocket league sports

2D car soccer demake. Drive, jump, and BOOST to fly — boost thrusts along the way you point, so you pull off aerials in the air. Punchy ball physics, cars bump each other. First to 5 wins. P1 blue: A/D drive, W jump, Z boost — P2 orange: </> drive, ^ jump, , boost.

rogue rpg

The original dungeon crawl. Every floor is procedurally generated — rooms joined by corridors — and revealed by line-of-sight fog of war as you explore. Turn-based: walk into a monster (rats, kobolds, orcs, trolls) to attack it, and it hunts you back. Grab gold and potions, gain XP and level up, and take the stairs deeper. Find the Amulet of Yendor on floor 8 to win. Death is permanent. Arrows / WASD move + attack, A quaffs a potion, B descends stairs.

shakespearean insults

Procedural text from three word lists. Pick one word from each column and glue them into Thou [A] [B] [C]! With ~50 words per column thats over a hundred thousand insults from one tiny program — that multiplication is combinatorics, and the picking is just rnd() indexing into arrays, the same trick behind procedural names and loot. Z hurls a fresh one.

sokoban puzzle

The warehouse puzzle classic. Push every crate onto a red goal dot. You can only PUSH (never pull) and only one crate at a time, so a crate shoved into a corner is stuck for good — plan ahead. Arrow keys walk and push, A undoes your last move, B restarts the level. Three built-in levels; solve one to advance. Levels are stored as plain text, so adding your own is easy.

solid 3D

PS1-era flat-shaded polygons — no textures, no GPU 3D. The wireframe filled in: every face is one trifill, sorted far-to-near (painter's algorithm, since there's no z-buffer) and culled when it faces away. Brightness comes from the face normal dotted with a light direction; the in-between shades are faked with fillp dither between two palette colours — which is exactly how you squeeze more than 32 shades out of the palette. Z toggles the dither off so you can watch the smooth gradient collapse into hard bands. X swaps icosahedron/cube, up/down zoom, L/R spin.

solvalou (xevious) shooter

A Xevious — the vertical shooter with TWO weapons for two layers: Z zaps flying enemies (toroids, zoshis), X drops a blaster bomb on the reticle ahead of you to hit GROUND targets (tanks, bases). Terrain scrolls past, ground bases shoot back, and the Andor Genesis mothership shows up for big points. WASD/arrows fly, Z zap, X bomb.

sopwith camel shooter

A WWI biplane bomber with a real flight model — the engine pushes you forward along the nose, gravity always pulls down, drag bleeds speed, so you stall if you climb too steeply and loop if you hold up. Bomb every enemy hangar and dogfight the red planes. W/S pitch the nose, Z machine gun, X drop a bomb.

sorting visualizer

Watch and hear sorting algorithms run. A sort only ever compares and swaps; this records that stream of operations and replays it slowly, lighting the bars it touches and playing a note pitched to each bar height. Bubble, selection, insertion and quicksort each make a very different sound. Z cycles algorithm, X shuffles, up/down change speed.

splatoon sandbox

2-player ink battle showing off pset/pget. Every shot paints pixels onto the canvas (which the engine never clears), and you read the ink ahead with pget to swim fast through your own color and slog through the enemy's. Most floor covered in 40s wins. P1 blue: WASD move, Z shoot — P2 orange: arrows move, , shoot.

street brawler fighting

A 2-player 1v1 fighting game. Each fighter is a state machine — walk, jump, crouch, block (hold away), punch, kick — and attacks have startup/active/recovery frames so spacing and timing decide the match. The fireball is a real quarter-circle motion (down, down-forward, forward + punch) read from an input buffer, the trick behind every fighting-game special. Best of 3. P1: WASD + Z/X. P2: arrows + comma/period.

tetris puzzle

The falling-block classic. All 7 tetrominoes with rotation (and wall kicks so they pivot off walls), a ghost piece showing where they'll land, a next-piece preview, soft drop and instant hard drop. Complete a horizontal line to clear it — four at once is a Tetris. Gravity speeds up every 10 lines, scoring rewards multi-line clears, best score saved. Left/Right move, Down soft-drop, Up hard-drop, Z/X rotate.

textured 3D

The full PS1 / picoCAD look: affine texture-mapped polygons plus dithered shading. Each cube face is mapped from the sprite sheet with tritex(), which smears the texture across the triangle in screen space with no perspective correction — so it warps and swims exactly like a PlayStation 1. A quad is two triangles, so the texture creases along the diagonal; pressing X subdivides each face into an N×N grid (re-projecting every sub-corner) and you watch that affine warp melt away — the trick real consoles used. After the texture, a fillp dither of black darkens faces turned from the light (25%, then 50%). Z toggles shading, X subdivides, up/down zoom, L/R spin.

the crowd

A plaza full of little 16×32 people walking, colliding and bouncing off each other and the screen edges — a stress test of the sprite system. The headline trick is pal()-recolored "magic" clothes: everyone shares just three sprite bodies, but each person's shirt (drawn in palette index 28) and pants (index 29) are swapped to random colors with pal() before drawing, so one tiny sprite set yields a whole varied crowd. Legs animate a 4-frame front-view march, agents are depth-sorted by their feet, and the ground is a real tile map() — grass, a cobbled crossroads, and scattered flowers. Z scatters everyone, X adds another person.

tiny city simulation

A little SimCity, mouse-driven. Pick a tool from the bottom bar, then click & drag on the map to build. Zone land Residential, Commercial or Industrial and connect it with Roads — zoned land only develops next to a road. Watch the R/C/I demand bars up top: build what is in demand and the city grows; taxes from buildings fund more building. Left-drag = build, right-drag = bulldoze, A cycles tools.

tower defense strategy

Creeps march along the path from left to right — build towers on the grass to stop them before they leak out the far side. Three tower types: GUN (cheap, fast), FROST (slows what it hits), and CANNON (slow but heavy splash). Kills earn gold to build more or upgrade existing towers (3 levels each). Twelve escalating waves with normal, fast, and tank creeps; survive them all to win. Move the cursor with arrows/WASD, A builds or upgrades, B switches tower type.

vampire survivors shooter

Stay alive in a thickening swarm. You only steer — your weapon auto-fires at the nearest enemy. Kills drop XP gems; scoop them up to level, and every level you pick one of three upgrades (damage, fire rate, multishot, magnet, pierce...). Enemies spawn faster and tougher the longer you last. WASD / arrows to move; at LEVEL UP Left/Right pick and Z confirm.

verlet rope

How games fake rope and cloth, cheaply. The rope is a line of points; each frame every point keeps moving the way it was already going (Verlet integration stores the previous position) and gravity tugs it down. Then the links are relaxed a few times — nudging each pair back to the right segment length — and believable rope falls out, no springs or forces. Arrows swing the anchor, Z flicks the tail, X flips gravity.

video poker tabletop

Jacks-or-Better video poker, the arcade classic. You are dealt five cards; click the ones to KEEP (or use Left/Right + A), then DRAW to replace the rest. A pair of Jacks or better pays out, with bigger hands paying more — see the schedule up top. The BET button cycles 1-5; max bet earns a Royal Flush bonus. Mouse-driven, B also deals/draws.

1. hello screen

Your very first cart. Clear the screen and print some text.

10. build a world

Paint tiles in the map editor. Your player walks through the world and the camera follows.

11. noise

Smooth organic randomness. Two layers of scrolling hills and twinkling stars, all from noise2().

12. high score

Mash buttons for 10 seconds. Your best score saves between runs with save() and load().

13. easing

ease_in, ease_out, ease_in_out — shape motion from robotic to natural. Four balls, four curves.

14. hud layout

A star spawns at a random spot and shrinks — press Z before it disappears to score. Miss it and lose a life. Shows print_centered and print_right for HUD layout.

15. animation phase

anim() with a phase offset — stagger multiple entities so they move out of sync with one line of code. v2: the 6-frame walk cycle is generated by one parametric walker(t) function (sprite-draw.js), recolored per walker with pal().

16. spirograph

Turtle graphics: a loop + a fixed turn angle = a pattern. Change ANGLE at the top to see 91°, 144°, and 97.2° shapes.

17. hypotrochoid

A point on a small circle rolling inside a larger one traces an intricate curve. Four presets (8-loop, 5-petal, 9-loop, trefoil) — press A to cycle. Uses the parametric equation directly with cos_deg and sin_deg.

2. shapes and colors

Draw rectangles, circles, lines, and pixels in all 32 palette colors.

3. things that move

Variables and the game loop — a ball bounces around using update() and velocity.

4. press a button

Read the keyboard with btn() and move a character around the screen.

5. draw your character

Open the sprites tab, draw a 16×16 character in slot 1, then see it move.

5b. colorkey

Make sprite backgrounds transparent with colorkey(). Step-by-step: see the pink box, make it vanish, float over any background.

6. sounds and music

Make noise with note(), bpm(), and every(). A simple beat and melody.

7. keeping score

Track a number and show it on screen. Press buttons to score and reset.

8. catch the star

A complete game — move your player, catch the star, hear the sound, beat your score.

9. enemies!

Add an enemy that chases you. Collision, game over, and restart.

asteroids shooter

Classic vector shooter. Rotate and thrust your ship, blast rocks apart, survive endless waves. Left/right to rotate, up to thrust, Z to fire.

breakout arcade

Classic brick-breaker. Rainbow rows of bricks, paddle angle controls the bounce direction. 3 lives. Left/right to move, A to launch.

frogger arcade

Classic Frogger. Hop across 4 lanes of traffic, ride logs across the river, land on all 5 lily pads to advance. Each round speeds up. 3 lives. Arrow keys to hop.

gorillas tactics

Classic QBasic Gorillas. Two gorillas on a city skyline take turns hurling exploding bananas. Adjust angle and power, account for wind. First to 3 hits wins. Left/right: angle — Up/down: power — Z: fire.

GTA sandbox

Top-down open world sandbox. Walk and shoot twin-stick, or jack a car and run people over. 5 stars = BUSTED. WASD: move/drive — Arrows: aim+shoot — Z: enter/exit car.

lunar lander arcade

Physics-based lander. Rotate and thrust your way onto the lit green pad slowly enough to survive. Levels get harder — pads get narrower. Left/right to rotate, up or Z to thrust.

paratrooper shooter

Rotate your AA gun and shoot down paratroopers before they capture it. Helicopters drop soldiers — shoot them in the air or on the ground. Game over when 2 reach each side of your gun. Left/right to aim, Z to fire.

platform game platformer

Side-scrolling platformer with sprites and a tile map. Stomp red enemies from above, collect coins, watch your lives. Left/right to move, Z or up to jump.

pong sports

2-player pong. First to 7 wins. Player 1: W/S — Player 2: up/down arrows.

robotron 2084 shooter

Twin-stick arena shooter. WASD to move, arrows to shoot 8-way. Rescue civilians, blast grunts and enforcers, dodge bullets. Brains convert civilians to zombies. Hulks can't be killed!

snake arcade

Classic snake. Eat the flashing food to grow, avoid walls and your own tail. Speeds up as you get longer. Arrow keys to steer.

space invaders shooter

Classic arcade shooter. 8×3 alien grid that speeds up as you clear it, 3 enemy bullets, lives. Left/right to move, A to shoot.