| SPACE | play / pause |
| P | panels: pinned bar ↔ floating |
| T | tap (pulse) |
| . | step one tick |
| R | reset engine |
| F | fullscreen (page); shift-F fullscreens the selected display object |
| B | bus inspector |
| * | favorites filter |
| C | export series CSV |
| S | export tile PNG |
| ? | this sheet |
| ESC | close panels |
| tap tile | bus inspector |
| hold tile | open bus inspector |
| drag widget | adjust knob / slider value |
| wheel widget | nudge value (fine step) |
| dblclick widget | reset to initial value |
| click toggle | flip on / off |
| drag XY pad | move mod.x / mod.y crosshair |
| wheel XY pad | nudge Y (shift+wheel nudges X) |
| widget sync | server echoes live params → widgets redraw (never mid-drag) |
| bi: control | prefixed widgets (sub.clk.bpm) route to the correct engine; ↺sub/↺con reset per side |
| S-PLAY | sweep replay: timed param batches (shift+click loops; program switch stops) |
| S-REC shift | echo-record mode: capture server param echoes, not just local commits |
| S-EXP/S-IMP | sweep export/import JSON round-trip |
| drag panel head | move floating panel (8px snap); drop on screen edge = dock |
| panel ▾ / corner | collapse panel / resize panel |
| arrows (+shift) | nudge focused panel 8px (shift: 1px) |
| drag display | pan/scrub view (series scroll, xy pan, wxyz3d orbit) |
| wheel display | zoom view; pinch = scale |
| dbl-tap tile | tile fullscreen (again to exit) |
| layout EXP/IMP | per-program layout save/restore + export/import JSON |
| scope 3D path | vendored three.min.js (r160, static/vendor/) → series/xy render as WebGL vector traces (locked ortho camera) |
| scope zoom | wheel/pinch drives the ortho camera; drag pans (canvas VFB is the fallback) |
| video/heat 3D path | vendored three.min.js → video frames upload as a DataTexture quad, heatmap as a palette shader quad (canvas VFB is the fallback) |
| 3D toggle + budget | menu 3D button (persisted) gates every overlay; WebGL probe falls back to canvas; overlay cap evicts the LRU scene; window.__ATOMIC_THREE counts renders/fallbacks/evictions (iter 59) |
| controls on the wall | controls live ONLY in .ctlpanel wall tiles (docked per module; grip drags free-float, corner resizes, geometry persists in the layout store); FLOAT toggles floating fpanel mode (iter 63) |
| span overlays | 3D overlays cover the view's full tile span (wall-mounted, span rect); wxyz3d VFB ghost fixed — canvas draws only as fallback (iter 60) |
| clear wall | program switch wipes the VFB + every tile canvas + chrome (2D teardown, paused-safe); stale bus cache evicted (iter 61) |
| theme-aware viz | all visualizers derive colors from the theme palette (vizPaletteColors); theme/accent change re-skins canvas + re-tints live 3D materials (iter 61) |
| theme-matched viz + font | viz colors anchored to theme chrome vars with a contrast floor; phosphor glow scales with the theme (iter 62); UI font is vendored Departure Mono (iter 63) |
| LLM chip + /edit | LLM chip polls /api/vllm/status (ok/down, send hinted when down); /edit [name] enters edit mode, /save program persists the layout server-side, /exit leaves — local commands, work with the LLM down (iter 64) |
| /optimize program | /optimize [name] asks the 27b-v2 duty LoRa for a signal-optimization pass (fewer wire hops, h4_slide batching, moving_avg→smooth); the server validates the candidate + checks lag-tolerant trace-replay parity and applies only when better — the pre-optimize program restores via POST /api/optimize/<p>/restore; python -m atomic.program_regen --regen <name> --apply regenerates registry programs as module cards (A/B harness, replace only when equal-or-better) (iter 87) |
| --regen-all sweep | python -m atomic.program_regen --regen-all [--apply] regenerates ALL registry programs via 27b-v2 with a per-program journal (replaced/kept + why, written to programs_generated_journal.json); landed builders become thin override pointers (build() prefers the green override) (iter 88) |
| module rack | GET /api/modules/<p> now carries a PatchSet payload — the program as a rack of independent modules (per-module hp/row/jacks, one module per core chain + one per viz sink); the wire overlay renders the rack strips and cross-module jack drags edit the underlying wires via the iter-64 edit path (iter 88) |
| /optimize bi: | bicameral programs optimize per side: POST /api/optimize/bi:<p> {side: sub|con} runs parity on that side only (bridge untouched), per-side restore via /restore {side}; overlay wire edits infer the sub side from the jack prefixes (iter 88) |
| slop prompt path | on slop programs (infinite_slop_loop / _bicameral): LLM-rewritten scene text auto-feeds the SlopLoop via POST /api/slop/<p>/prompt (queue beats H4 consensus); LLM down → raw prompt falls back to the slop loop; H3 chip polls /api/fasth3/status, distinct from the LLM chip (iter 65) |
| slop status chip | SLOP chip (slop programs only) shows current prompt + queue depth from GET /api/slop/<p>/stats, polled every 3s; slop start auto-wires the live FastH3 backend (FASTH3_URL, default :8189, ComfyUI mode, stub fallback) — no h3_url payload needed; FASTH3_URL=stub forces the synth stub (iter 66) |
| clip pump | one font (Departure Mono) for ALL UI text incl. canvas readouts (boot preloads the woff2); POST /api/feed_video/<p>/clip_prompt makes a prompt return a real clip (default FastH3 wiring); /random_clip plays 5–30s of a random Jellyfin title at a random position; /feed_url pumps any ffmpeg URL/stream; 'play <title>' in the LLM bar resolves + plays the full Jellyfin title via /api/jellyfin/play (iter 67) |
| edit-mode wiring | in edit mode: click two tiles to wire their modules (alt = cut), server revalidates the IR + rebuilds the engine; control widgets scale with the resized panel (iter 64) |
| jellyfin live + yt-dlp | Jellyfin env drop-in (192.168.1.43) makes /api/jellyfin/* live; 'play <title>' misses fall back to the duty LLM picking from the library (llm_used flag); watch-page URLs auto-resolve via yt-dlp -g; opening a slop program auto-starts the loop once (iter 68) |
| slop dogfood fixes | vLLM model id resolved from /v1/models (no more 404 on "default"); slop loops tick server-side without a WS client (last_error surfaced); prompt FIFO capped at 8 drop-oldest (▶/⚠ on the chip); feed_video_live chains random clips forever (on_end=random_next, freeze-last-frame on stop); clip_prompt honors n_frames (iter 69) |
| SMB fallback + LoRa corpus | Jellyfin down? clips/play fall back to the NAS SMB shares (smbclient→ffmpeg stdin, smb:// URLs) so the wall never starves; duty-LLM interactions (title picks, vllm prompts) archive into lora-corpus.qbf with Backlot-format JSONL export for the atomic-computing LoRa; slop channels log rotation history and archive per-channel QBF sessions (/api/slop_channel/archive); python -m examples.ui_e2e is the headless 10-check e2e (iter 70) |
| livetv tuner + pump | point Jellyfin's M3U Tuner at /api/slop_channel/m3u — atomic-ui serves /livetv/<cid>/live.m3u8 + segments itself (ATOMIC_LIVETV_BASE advertises the LAN address), zero file installs; slop channels self-pump via a daemon tick thread (auto-rotate every K steps, auto-archive QBF on stop, pump liveness in /status); corpus chip (lora:N) counts archived interactions — from_description/swarm H4 consensus/evolve generations now join the corpus, export filterable via ?kind=; python -m examples.ui_playwright_e2e runs the 11-check real-browser e2e (iter 78) |
| on air + corpus ops | python -m examples.livetv_onair_dogfood puts the channel on air with real ffmpeg HLS (mock=false) + ffprobe tune-in + LAN playlist probe — register CrystalPalace's M3U Tuner at http://<atomic-host>:18093/api/slop_channel/m3u (drop-in scripts/atomic-ui.service.d/30-livetv.conf); slop_channel/start wires FastH3Client per loop via the FASTH3_URL probe (h3_url/stub overrides, h3_kind in /status) and the pump survives slow generations (generating/last_step_s/slow_steps; tv chip #slopch-chip); corpus shards rotate at ATOMIC_LORA_MAX_ENTRIES with dedupe + ts/size stats, python -m examples.lora_training_export snapshots Backlot JSONL; playwright e2e asserts canvas frames non-black, 12/12 mock + --live (iter 79) |
| display catalog | standardized module display hardware — one DISPLAY_TYPES registry in app.js pins the four physical display SVG plates (4INCRT/5INLCD/242OLED/GBDISPLAY) to a native framebuffer resolution + material family + physical frame/screen rect (mm) + bezel color. Every display object renders through the SAME three.js virtual-CRT flow (canvas→texture→quad); material ∈ {crt, lcd, oled, dmg}. 'd' cycles crt4→lcd5→oled128x64→dmg; legacy iter-84 mode ids normalize via DISP_LEGACY. dispRect applies dispFitRect (letterbox to physical aspect ratio; resizable units fill the span), and renderViewCrt draws VFB slice into the displayport sub-rect with bezel fill. OLED = createFlatQuad 1-bit SSD1309 threshold, LCD = flat quad NearestFilter, CRT = vendored shader at 320×240, DMG = new createGbQuad porting hoa64 DMG_FRAG essence (4-shade palette quantize + 1px grid + frame ghosting via ping-pong uPrev canvas) at 160×144 (iter 89) |
| display catalog e2e | playwright real-browser test cycling all 4 display types (CRT/LCD/OLED/DMG) on the wall — canvas non-black assertion per mode, theme-aware DMG palette check (dmg theme → DMG ink ramp), layout persist/restore using new type ids; extends ui_playwright_e2e.py with a new display_catalog check function (iter 90/91) |
| display-mode chip | small #disp-mode-chip in the wall chrome shows active display type id + scale (e.g. "DMG ×1.0") for the selected tile, updates on mode/scale change; appears only while a display object is live on the selected tile (iter 91) |
| wall-clock pacing + multichannel | repeat=true (default for mock=false) holds the last frame at fps so even ~44s/frame FastH3 channels segment every 2s of wall time — livetv_onair_dogfood asserts the first segment lands <60s; POST /api/jellyfin/register_tuner (or dogfood --register) auto-adds the M3U tuner on CrystalPalace and verifies /LiveTv/Channels; lora export takes since=/--incremental + writes a .manifest.json sidecar (stats last_export_ts) — train: python ~/backlot/train_lora.py --data <snapshot.jsonl> --base <duty-llm> --out <lora> --epochs 3; python -m examples.multichannel_universe_dogfood puts ≥2 channels on air with per-channel tvg-chno numbers, the M3U lists them all, and the tv chip shows "Nch" (iter 80) |
| wdf/faust atoms | wdf_* atoms (R/C/L leaves, series/parallel adaptors, diode pair, rc/rcl composite lowpass — bilinear-exact pole; demo program wdf_rcl_lowpass, keywords: "rc lowpass filter"); C++ chowdsp_wdf subprocess oracle parity 4e-16 (scripts/wdf_oracle, XSIMD→ESIMD/B70 documented, no SYCL); faust_vocab ingests 6264 fns from ~/faustlibraries into teach faust/dsp domains + faust_expr atom (safe parser, mem = 1-sample delay); lora-vocab shard seeds 60 Pd/EEL2/JS/WDF/Faust/transistor entries; scouts: LightGlue-ONNX feat_match fitness + Heaviside-1 em_field contract (external services, nothing vendored) (iter 81) |
| audit + LoRa eval + circuitjs | python -m atomic.audit_definitions prints the CORE⇄catalog conformance table (63 atoms, 0 problems; drift = UNACCOUNTED row or missing test pin); python -m atomic.lora_eval --selftest checks the 10-task eval set offline, --base-url/--model scores one model, --compare base.json lora.json is the measured LoRa gate (pass = score ≥ base, no regressions); atomic/circuitjs_import.py sketches circuitjs1 netlists onto wdf_*/gate_* atoms (probe, not runnable yet) (iter 82) |
| d = display mode | cycle the selected tile's display-object emulation: 4INCRT → 5INLCD → 2.42in OLED → DMG; enables the object if off; persists per program in the layout store's disp bucket (iter 89-90) |
| - / = resize display | shrink/grow the selected display object about its tile-span center (0.25× steps, clamp 0.25–4×, persisted per view) (iter 84) |
| F = fullscreen display | shift-F fullscreens the SELECTED display object over the wall; Esc/F exits; plain f stays page fullscreen (iter 84) |
| W = wire overlay | patch-bay layer over the wall: everything else fades, module i/o points render as jacks; drag out-jack → in-jack to patch (server revalidates the IR + rebuilds the engine), click a wire to remove it; patched wires persist in the layout store's wires list and re-apply on load; w/Esc exits (iter 85) |
| HP panel rules | program panels follow Eurorack/VCV metrics from 1HP-PANEL.svg: 1HP = 5.08 mm wide, 128.5 mm tall (3U); control-panel x/width snap to integer HP (min 2HP, 8px = 1HP on screen), two rows max per program — layout entries carry {hp, row, wHp} and legacy float-px layouts migrate to the nearest HP snap on load (iter 84) |
| v = CRT overlay | click a tile to select it, then v toggles the CRT shader overlay for that view (series/xy/heatmap/video): VFB slice → GPU texture → curved scanline CRT quad (vendored crt-shader.js, MIT threejs-crt-shader port); canvas VFB is the fallback, CRT overlays count against the 3D budget, scanline intensity + curvature scale with the theme's --glow-eff, toggles persist per program in the layout store (iter 83) |
| + palette / drag | RACK toggle + button opens a right-edge palette drawer listing all atoms from GET /api/catalog; drag (or click) any atom onto the wire overlay to POST /api/program/<name>/edit {ops:[{op:"add_block", id, primitive}]} and add a new module card to the rack; rack panel fills the row height (tall panels like rackdemo.png) and draws the module's display thumbnail inside (iter 105) |
| code wires | add_wire ops can carry kind="code"; code_out (param code string) emits the string; code_in re-emits its input string; wires of kind code are a second latch pass in the engine that joins multiple inputs with \n, enabling compile-time code injection across patch cables (iter 105) |