diff --git a/xbox/OBJECT-DIALECT.md b/xbox/OBJECT-DIALECT.md
index caa9bba1c2..d1afe3e585 100644
--- a/xbox/OBJECT-DIALECT.md
+++ b/xbox/OBJECT-DIALECT.md
@@ -4,14 +4,19 @@ Props, vehicles, weapons and hats are small KidLisp programs. You write one
 in Aesel (a `.lisp` file, the same KidLisp runtime), try it in the object lab,
 and then seal it into the game. The same compiled object runs on every
 oskiewar host. All it sends is frame ops (`OSKIEWAR-HOSTS.md` §3.0): WORLD
-faces, which every interpreter already reads, and one new op, MODEL.
-
-**Forms compile away; hosts see faces and meshes.** Everything in this
-dialect, from `revolve` to `radial` to `mirror` to level of detail, is
-expanded once, by `object-lisp.mjs`, when the object loads. No interpreter
-ever expands a form. Each host (JS web, C++ Xbox, and whatever comes next)
-implements only WORLD, ASSET and MODEL. That rule keeps `FrameVm.cpp` small
-and keeps the hosts from drifting apart.
+faces, which every interpreter already reads, and baked parts by handle —
+lit meshes (MODEL) or, in the flat style @jeffrey chose to try, flat
+sketches (SKETCH).
+
+**Forms compile away; hosts see faces, meshes and flat shapes.** Everything
+in this dialect, from `revolve`, `radial`, `mirror`, `toward` and `slab` to
+level of detail, is expanded once, by `object-lisp.mjs`, when the object
+loads. No interpreter ever expands a form. Each host (JS web, C++ Xbox, and
+whatever comes next) implements only WORLD, ASSET/MODEL and SHAPES/SKETCH
+(plus ELLIPSE, PLATE and OUTLINE for flat shapes that move per tick). What a
+host does with them is project, fill, light or ink, and pick sides or a
+level. That rule keeps `FrameVm.cpp` small and keeps the hosts from drifting
+apart.
 
 Written 2026-09-28. Status:
 
@@ -19,8 +24,10 @@ Written 2026-09-28. Status:
 |---|---|---|
 | compiler | `xbox/live/object-lisp.mjs` | done; tests in `xbox/live/tests/object-lisp.test.mjs` |
 | MODEL op | `xbox/live/frame-vm.mjs` (op 14) | done on the web; test in `tests/frame-vm.test.mjs`; the game's op table and `FrameVm.cpp` (R6) still need it |
-| first object | `xbox/live/objects/monowheel.lisp` | done: tire wedges, rim, web, 5 spokes rolling with distance, lean, landing squash, turbo, lamps |
-| lab | `xbox/live/object-lab.html` (`npm run xbox:play`, then `/object-lab.html`) | done; shows each tick's cost |
+| flat ops | `frame-vm.mjs` ops 15–19: ELLIPSE, PLATE, OUTLINE, SHAPES, SKETCH | done on the web; tests in `tests/frame-vm.test.mjs`; the game's op table and `FrameVm.cpp` still need them |
+| first object, lit | `xbox/live/objects/monowheel.lisp` | done: tire wedges, rim, web, 5 spokes rolling with distance, lean, landing squash, turbo, lamps |
+| first object, flat | `xbox/live/objects/monowheel-flat.lisp` | done: inked tire, rim, web, spoke bars that roll, drawn-box deck, lamp dots, ground shadow, lean, landing squash, turbo |
+| lab | `xbox/live/object-lab.html` (`npm run xbox:play`, then `/object-lab.html`) | done: lit left, flat right, one set of sliders; each pane shows its tick's cost |
 | in the game | `xbox/tools/embed-objects.mjs` + `drawMonowheel` | **next pass**, see below |
 
 ## The budget
@@ -28,24 +35,32 @@ Written 2026-09-28. Status:
 This rule holds for every object, and `object-lisp.test.mjs` fails the
 monowheel if it breaks it:
 
-- **A tick sends at most 150 numbers** (MODEL ops + WORLD faces), of which
-  **at most 8 are moving WORLD faces**. Everything else is baked.
-- **The host draws at most 150 / 100 / 80 triangles** at levels 0 / 1 / 2.
-- Baked meshes go up once, as ASSETs, when the object loads.
+- **Flat (the target):** a tick sends **at most 60 numbers**, and at every
+  distance the host draws **fewer triangles than the lit version**.
+- **Lit:** a tick sends at most 150 numbers, of which at most 8 are moving
+  WORLD faces, and the host draws at most 150 / 100 / 80 triangles at
+  levels 0 / 1 / 2.
+- Baked meshes and sketches go up once, as ASSET and SHAPES, when the object
+  loads.
 
-Measured on the monowheel (the old rows come from the game's own frame
-program; µs are Node on a Mac at load average ~400, so compare them only
-with each other):
+Measured on the monowheel. The old row comes from the game's own frame
+program. Distances are the lab camera's (220 is a close-up, and 600 to 1500
+spans gameplay). µs are Node on a Mac at load average ~400, so compare them
+only with each other:
 
-| | a tick sends | host triangles | JS per tick |
+| | a tick sends | host triangles at 220 / 600 / 1500 / 4000 | JS per tick |
 |---|---|---|---|
-| the game's flat monowheel today | 88 WORLD = **1144 numbers** | 88 | — |
+| the game's flat monowheel today | 88 WORLD = **1144 numbers** | 88 at every distance | — |
 | first object slice (all faces) | 260 WORLD = 3380 numbers | 260 | ~150 µs |
-| **now** | 2 MODEL + 4 WORLD = **92 numbers** | **148 / 92 / 80** by level | ~14–38 µs |
+| lit, baked | 2 MODEL + 4 WORLD = **92 numbers** | 148 / 96 / 92 / 80 | ~12–20 µs |
+| flat, projected in JS every tick | ~17 flat ops = 168 numbers | 134 / 85 / 55 / 47 | ~35 µs |
+| **flat, baked** | **3 SKETCH = 42 numbers** | **~125 / 84 / 55 / 33** | **~3–7 µs** |
 
-The 4 WORLD faces are the lamps, whose brightness follows speed. 10 meshes
-are uploaded once: the wheel at 3 levels × 2 turbo values, and the decks at
-2 distinct levels × 2.
+- **Lit:** the 4 WORLD faces are the lamps, whose brightness follows speed.
+  10 meshes are uploaded once: the wheel at 3 levels × 2 turbo values, and
+  the decks at 2 distinct levels × 2.
+- **Flat:** 5 sketches are uploaded once: the shadow, the wheel × 2 turbo,
+  and the deck × 2 turbo.
 
 ## Why the compiler does it all
 
@@ -187,6 +202,55 @@ monowheelObject(inputs, place, { face: emitWorldFace, model: emitModel });
 - **Faces only:** passing a single function instead draws everything as WORLD
   faces at level 0. That is the path the tests use to check the baking.
 
+## The flat style
+
+@jeffrey: "wishes we sort of drew everything in 2d even though the game is in
+3d." The world and gameplay stay 3D. Drawing is world-anchored 2D: an object
+names anchor points in its own space, the host projects them through the
+frame's CAMERA, and it fills flat 2D shapes at the projected size.
+
+- **Style:** each shape is a flat fill with an ink edge and no lighting
+  gradient. Each shape carries one flat depth, so near shapes cover far ones,
+  and objects keep a ground shadow.
+- **Forms:** `(ball x y z r)`, `(limb a b r)` (a stadium), `(ring axis r)`
+  (a circle drawn as its projected ellipse), `(drum axis r width)` (a
+  cylinder), `(stroke w …)`, `(plate …)` and `(slab x1 y1 z1 x2 y2 z2)`.
+- **Scopes:** `(outline w [r g b] …)` gives the shapes inside an ink edge `w`
+  world units wide. `(nudge d …)` pushes shapes `d` world units back to settle
+  ties. `(toward axis …)` shows the side of that axis that faces the camera,
+  which is how a wheel shows the face you can see.
+- **Baking:** a run of flat shapes that reads nothing per tick bakes into a
+  sketch (op 18 SHAPES), exactly as lit faces bake into meshes. Each tick
+  sends one 14-number SKETCH (a handle and the part's placement). The host:
+  - projects each shape's anchors;
+  - skips a one-sided shape turned away from it (that is what `toward` and
+    `slab` bake into);
+  - picks an ellipse's side count from its projected size, keeping chords
+    within 2 px of the curve (4–24 sides);
+  - draws the ink edge first, a hair behind, and leaves it off under half a
+    pixel;
+  - skips anything under a pixel.
+- **Moving shapes:** a flat shape that does read a per-tick input is
+  projected in JS and sent as ELLIPSE / DISC / CAPSULE / PLATE, with OUTLINE
+  sent only when the edge changes.
+- **Drum:** it draws the far end's outer half, the band between the ends'
+  tangent points, and the near end, each at its own depth. The far end's
+  inner half is never drawn, because the band covers it.
+- **Slab:** it bakes as six one-sided faces, so the host draws the three it
+  can see, each inked. It reads as a drawn box.
+
+**What it costs to keep it cheap.** Ink doubles what it outlines, so only
+silhouettes carry it (the tire and the deck). Details sit on fills that
+already contrast. Spokes are flat bars, two triangles each, where a round
+end costs eight. These are authoring rules, not engine limits.
+
+**Depth reads.** In the lab shots, the near cap covers the band and the band
+covers the far cap. The deck sits behind the tire, and the tire pokes through
+it. The front lamp hides behind the deck end at ¾. Seen from the left, the
+wheel shows its other face. The shadow lies under everything. What's lost is
+shading inside a surface: a cylinder reads by its silhouette and ink, not a
+gradient.
+
 ## Figures
 
 §7 decision 0 option (b) re-expresses figures as world-space primitives. The
@@ -199,12 +263,31 @@ need skinning, and that is a separate decision. With this route, FIGURE is not
 needed as an op, and the figure's forms, like the objects', compile away in
 one place.
 
+**Option (c), world-anchored flat shapes,** is the flat style applied to
+figures, and it suits them better than (b):
+- **Parts:** a figure is balls (head, hands, joints) and limbs (stadiums
+  between joints), with a torso as a plate or a drum, all inked.
+- **Bending:** bending parts stop being a problem, because a limb is two
+  anchors and a width, projected every tick.
+- **Cost:** the pose is the per-tick data, about 12 joints. A figure needs no
+  mesh: it is a sketch whose anchors are joint slots rather than fixed
+  points. The host already projects anchors and fills stadiums and discs, so
+  the only addition is a record that takes its anchor from the pose (a
+  joint index) instead of the sketch.
+- **Per-figure numbers:** about 12 joints × 3 plus a style handle, roughly
+  40–50 numbers, against today's ~1700 screen-space ops for all figures.
+- **Face and hair:** flat plates and strokes anchored to the head.
+
 ## Next pass: into the game
 
 Don't touch `oskiewar.js` without running `npm run xbox:burn:oskiewar-social`
 (the manifest is hash-bound). About 41 tests already fail at HEAD, so compare
 against that baseline.
 
+0. **Flat or lit.** If the flat style is chosen, the steps below carry
+   SHAPES/SKETCH (ops 18/19) where they say ASSET/MODEL: `emitSketch(handle,
+   frame, at)`, sketches uploaded once, and an immediate fallback that runs
+   `frame-vm.mjs`'s `drawSketch` rule through `worldTriangle`.
 1. **MODEL in the game's op table.** Add op 14 (20 numbers) to the table at
    the head of the frame-program section. Add an `emitModel(radius, h0, h1,
    h2, frame, at)` that writes it with `globalLight`. For hosts without
diff --git a/xbox/OSKIEWAR-HOSTS.md b/xbox/OSKIEWAR-HOSTS.md
index e96a1eb651..970e878f0f 100644
--- a/xbox/OSKIEWAR-HOSTS.md
+++ b/xbox/OSKIEWAR-HOSTS.md
@@ -108,6 +108,12 @@ MODEL    radius · handle×3 · model[12] · light    op 14, in frame-vm.mjs sin
                                                   under a placement, at one of three baked levels picked by
                                                   projected radius (56 / 20 px); normals by cofactor, zero = unlit.
                                                   Objects (xbox/OBJECT-DIALECT.md) are MODELs plus a few WORLD faces
+ELLIPSE  x y depth · a(2) b(2) · rgb             op 15: a projected circle, flat, sides by projected size
+PLATE    n · n×(x y) · depth · rgb               op 16: a flat convex polygon
+OUTLINE  width · rgb                             op 17: ink edges on the flat shapes that follow; 0 stops
+SHAPES   handle count length · records           op 18: an object's baked flat shapes (ball, limb, ring, plate, drum)
+SKETCH   handle · model[12]                      op 19: draw kept shapes placed: project anchors, fill flat, ink,
+                                                  skip one-sided shapes turned away. The flat style (2026-09-28)
 FACE     3×(x y z) · rgb · depth                  escape hatch for one-off geometry; interpreters may lower to it
 DISC     x y z · r · rgb           CAPSULE  x1 y1 z1 x2 y2 z2 · w · rgb
 RIBBON   cubic (4 pts) · w · rgb                  limbs, hair, skirt edges
@@ -258,6 +264,16 @@ drawn once and look the same everywhere.
   drift. This is also a route for §7 decision 0 option (b): a figure's rigid
   parts as baked meshes under moving bone frames, one MODEL each, with the
   same forms compiling away in the same place.
+  **Flat, 2026-09-28:** @jeffrey chose to try world-anchored 2D drawing
+  (flat fills, ink edges, flat depth per shape). `objects/monowheel-flat.lisp`
+  is the monowheel that way, side by side with the lit one in the object lab.
+  It bakes to three SKETCH ops, 42 numbers a tick, and the host draws fewer
+  triangles for it than for the lit one at every distance. The same shapes
+  are a third answer to §7 decision 0: **(c) figures as world-anchored flat
+  shapes**, balls and stadiums between projected joints, inked. It avoids
+  (a)'s second painter, and unlike (b) it bends for free, because a limb is
+  two anchors and a width. See `xbox/OBJECT-DIALECT.md` → The flat style,
+  Figures.
 
 ## 6. Order
 
diff --git a/xbox/live/object-lab.html b/xbox/live/object-lab.html
index d97fb02391..89df9a69f8 100644
--- a/xbox/live/object-lab.html
+++ b/xbox/live/object-lab.html
@@ -19,23 +19,26 @@
   }
   * { box-sizing: border-box; }
   body { margin: 0; background: var(--bg); color: var(--ink); font: 13px/1.4 ui-monospace, "SF Mono", Menlo, monospace; }
-  main { display: grid; grid-template-columns: minmax(0, 1fr) 380px; gap: 12px; padding: 12px 16px; max-width: 1500px; margin: 0 auto; }
+  main { display: grid; grid-template-columns: minmax(0, 1fr) 340px; gap: 12px; padding: 12px 16px; max-width: 1800px; margin: 0 auto; }
   @media (max-width: 960px) { main { grid-template-columns: 1fr; } }
   h1 { font-size: 15px; margin: 0 0 4px; }
   h2 { font-size: 13px; margin: 12px 0 6px; }
   .sub { color: var(--dim); margin: 0 0 10px; }
+  .panes { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; }
+  @media (max-width: 700px) { .panes { grid-template-columns: 1fr; } }
   .view { background: var(--panel); border: 1px solid var(--line); border-radius: 8px; overflow: hidden; position: relative; }
   canvas { width: 100%; aspect-ratio: 16 / 9; display: block; }
   .view b { position: absolute; left: 8px; top: 4px; color: var(--dim); font-weight: normal; }
+  .view .status { margin: 0; padding: 4px 8px 6px; border-top: 1px solid var(--line); min-height: 3em; }
   aside { background: var(--panel); border: 1px solid var(--line); border-radius: 8px; padding: 10px; align-self: start; }
   label { display: grid; grid-template-columns: 84px 1fr 52px; gap: 6px; align-items: center; margin: 3px 0; }
   label span:last-child { text-align: right; color: var(--dim); }
   input[type=range] { width: 100%; accent-color: var(--accent); }
-  button { font: inherit; background: var(--panel); color: var(--ink); border: 1px solid var(--line); border-radius: 6px; padding: 4px 9px; cursor: pointer; }
+  button, select { font: inherit; background: var(--panel); color: var(--ink); border: 1px solid var(--line); border-radius: 6px; padding: 4px 9px; cursor: pointer; }
   button:hover { border-color: var(--accent); }
   .row { display: flex; flex-wrap: wrap; gap: 6px; margin: 8px 0 0; }
   textarea { width: 100%; min-height: 360px; font: 12px/1.45 ui-monospace, "SF Mono", Menlo, monospace; background: var(--bg); color: var(--ink); border: 1px solid var(--line); border-radius: 6px; padding: 8px; resize: vertical; tab-size: 2; }
-  .status { color: var(--dim); margin: 6px 0 0; }
+  .status { color: var(--dim); }
   .error { color: var(--bad); white-space: pre-wrap; margin: 6px 0 0; }
 </style>
 </head>
@@ -43,10 +46,13 @@
 <main>
   <section>
     <h1>Object Lab</h1>
-    <p class="sub">An oskiewar object is a KidLisp program. It compiles once: what never moves is baked into meshes at three levels of detail, and each tick sends one MODEL op per mesh plus WORLD faces for what does move. The game's own frame interpreter draws it here.</p>
-    <div class="view"><b id="name"></b><canvas id="stage" width="1280" height="720"></canvas></div>
-    <p class="status" id="status"></p>
-    <h2>source <span class="sub">— edit to recompile</span></h2>
+    <p class="sub">One oskiewar object two ways, through the game's own frame interpreter, driven by the same inputs and camera. Left, lit: what never moves is baked into meshes, sent as MODEL ops. Right, flat: world-anchored 2D shapes with ink outlines, baked as sketches the host projects and fills, sent as SKETCH ops.</p>
+    <div class="panes" id="panes">
+      <div class="view"><b id="litName"></b><canvas id="lit" width="1280" height="720"></canvas><p class="status" id="litStatus"></p></div>
+      <div class="view"><b id="flatName"></b><canvas id="flat" width="1280" height="720"></canvas><p class="status" id="flatStatus"></p></div>
+    </div>
+    <h2>source <select id="which"><option value="lit">lit</option><option value="flat">flat</option></select>
+      <span class="sub">— edit to recompile</span></h2>
     <textarea id="source" spellcheck="false"></textarea>
     <p class="error" id="error"></p>
   </section>
@@ -61,31 +67,59 @@
   </aside>
 </main>
 <script type="module">
-import { compile, objectInputs, objectLight } from "./object-lisp.mjs";
-import { createFrameVm, FRAME_CAMERA, FRAME_WORLD, FRAME_ASSET, FRAME_MODEL } from "./frame-vm.mjs";
+import { compile, objectLight } from "./object-lisp.mjs";
+import { createFrameVm, FRAME_CAMERA, FRAME_WORLD, FRAME_ASSET, FRAME_MODEL, FRAME_DEPTH,
+  FRAME_DISC, FRAME_CAPSULE, FRAME_ELLIPSE, FRAME_PLATE, FRAME_OUTLINE, FRAME_SHAPES,
+  FRAME_SKETCH } from "./frame-vm.mjs";
 import WebGLOskiewarScene3D from "./scene3d-webgl.mjs";
 
 const params = new URLSearchParams(location.search);
 const still = params.has("still");             // freeze for screenshots
 const objectName = params.get("object") || "monowheel";
 const W = 1280, H = 720;
-
-// ——— the host: WebGL with a depth buffer, or a depth-sorted Canvas2D ———
-const canvas = document.getElementById("stage");
-let gl = null, flat = null;
-try { gl = new WebGLOskiewarScene3D(canvas); gl.setLogicalSize(W, H); }
-catch { flat = { faces: [], ctx: canvas.getContext("2d") }; }
-let hostTriangles = 0;   // what the object cost the host this frame
-const faceSink = gl ? (...f) => { hostTriangles++; gl.triangle3d(...f); }
-  : (...f) => { hostTriangles++; flat.faces.push(f); };
-const noOp = () => {};
-const vm = createFrameVm({ triangle3d: faceSink, triangle: noOp, box: noOp, line: noOp,
-  wipe: noOp, write: noOp, systemWrite: noOp, comicWrite: noOp });
 const color = (name) => getComputedStyle(document.documentElement).getPropertyValue(name).trim();
 const rgb = (hex) => [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16));
+const noOp = () => {};
+
+// ——— a pane: a host (WebGL with a depth buffer, or a depth-sorted canvas),
+// its interpreter, its program, and the object it draws ———
+function pane(kind) {
+  const canvas = document.getElementById(kind);
+  const p = { kind, canvas, gl: null, flat: null, program: new Float32Array(1 << 15), length: 0,
+    object: null, source: "", handleBase: 0, sketchBase: 0, uploaded: true, tick: {}, triangles: 0, numbers: 0, us: 0 };
+  try { p.gl = new WebGLOskiewarScene3D(canvas); p.gl.setLogicalSize(W, H); }
+  catch { p.flat = { faces: [], ctx: canvas.getContext("2d") }; }
+  const sink = p.gl ? (...f) => { p.triangles++; p.gl.triangle3d(...f); }
+    : (...f) => { p.triangles++; p.flat.faces.push(f); };
+  p.vm = createFrameVm({ triangle3d: sink, triangle: noOp, box: noOp, line: noOp,
+    wipe: noOp, write: noOp, systemWrite: noOp, comicWrite: noOp });
+  p.push = (...values) => {
+    if (p.length + values.length > p.program.length) {
+      const next = new Float32Array(p.program.length * 2); next.set(p.program); p.program = next;
+    }
+    p.program.set(values, p.length);
+    p.length += values.length;
+  };
+  // Each op the object sends, counted by name.
+  const op = (name, fn) => (...a) => { p.tick[name] = (p.tick[name] || 0) + 1; fn(...a); };
+  p.out = {
+    face: op("WORLD", (...f) => p.push(FRAME_WORLD, ...f)),
+    model: op("MODEL", (radius, h0, h1, h2, m, at) => p.push(FRAME_MODEL, radius,
+      p.handleBase + h0, p.handleBase + h1, p.handleBase + h2, ...m.subarray(at, at + 12), ...objectLight)),
+    sketch: op("SKETCH", (h, m, at) => p.push(FRAME_SKETCH, p.sketchBase + h, ...m.subarray(at, at + 12))),
+    disc: op("DISC", (...a) => p.push(FRAME_DISC, ...a)),
+    capsule: op("CAPSULE", (...a) => p.push(FRAME_CAPSULE, ...a)),
+    ellipse: op("ELLIPSE", (...a) => p.push(FRAME_ELLIPSE, ...a)),
+    plate: op("PLATE", (n, points, depth, r, g, b) => p.push(FRAME_PLATE, n, ...points, depth, r, g, b)),
+    outline: op("OUTLINE", (...a) => p.push(FRAME_OUTLINE, ...a)),
+    view: null,
+  };
+  return p;
+}
+const panes = { lit: pane("lit"), flat: pane("flat") };
 
 // ——— controls ———
-const state = { time: 0, distance: +(params.get("distance") || 0), speed: 240, lean: 0, heading: 0,
+const state = { time: 0, distance: 0, speed: 240, lean: 0, heading: 0,
   pitch: 0, turbo: 0, hit: 1e9, land: 1e9,
   yaw: -.65, elev: .32, dist: 260, perspective: .82 };
 for (const key of Object.keys(state)) if (params.has(key)) state[key] = +params.get(key);
@@ -112,60 +146,40 @@ document.getElementById("play").onclick = (e) => { playing = !playing; e.target.
 document.getElementById("land").onclick = () => { state.land = 0; };
 document.getElementById("hit").onclick = () => { state.hit = 0; };
 
-// ——— the object: fetched, compiled once, recompiled on edit ———
+// ——— the objects: fetched, compiled once, recompiled on edit ———
 const sourceBox = document.getElementById("source"), errorBox = document.getElementById("error");
-// Each compile gets fresh handles, so its meshes go up once, as ASSETs, the
-// way the game would upload them when an object loads.
-let object = null, compileMs = 0, handleBase = 0, uploaded = true;
-function build() {
+const which = document.getElementById("which");
+function build(p) {
   try {
     const t = performance.now();
-    const next = compile(sourceBox.value, objectName);
-    compileMs = performance.now() - t;
-    handleBase += object ? object.meshes.length : 0;
-    object = next;
-    uploaded = false;
+    const next = compile(p.source, `${objectName} (${p.kind})`);
+    p.compileMs = performance.now() - t;
+    // Fresh handles per compile, so its meshes go up once, as ASSETs.
+    p.handleBase += p.object ? p.object.meshes.length : 0;
+    p.sketchBase += p.object ? p.object.sketches.length : 0;
+    p.object = next;
+    p.uploaded = false;
     errorBox.textContent = "";
   } catch (error) { errorBox.textContent = error.message; }
 }
-document.getElementById("name").textContent = `objects/${objectName}.lisp`;
-sourceBox.value = await (await fetch(`objects/${objectName}.lisp`)).text();
-build();
-let pending = 0;
-sourceBox.oninput = () => { clearTimeout(pending); pending = setTimeout(build, 150); };
-
-// ——— the frame program: CAMERA, a floor, the object's WORLD faces ———
-let program = new Float32Array(1 << 15), length = 0;
-const room = (n) => {
-  if (length + n <= program.length) return;
-  const next = new Float32Array(program.length * 2); next.set(program); program = next;
-};
-function worldFace(ax, ay, az, bx, by, bz, cx, cy, cz, r, g, b) {
-  room(13);
-  program.set([FRAME_WORLD, ax, ay, az, bx, by, bz, cx, cy, cz, r, g, b], length);
-  length += 13;
+for (const p of Object.values(panes)) {
+  const file = `objects/${objectName}${p.kind === "flat" ? "-flat" : ""}.lisp`;
+  document.getElementById(`${p.kind}Name`).textContent = file;
+  p.source = await (await fetch(file)).text();
+  build(p);
 }
-const tick = { faces: 0, models: 0 };
-const out = {
-  face: (...f) => { tick.faces++; worldFace(...f); },
-  model: (radius, h0, h1, h2, m, at) => {
-    tick.models++;
-    room(20);
-    program.set([FRAME_MODEL, radius, handleBase + h0, handleBase + h1, handleBase + h2,
-      ...m.subarray(at, at + 12), ...objectLight], length);
-    length += 20;
-  },
+const showSource = () => { sourceBox.value = panes[which.value].source; };
+which.onchange = showSource;
+showSource();
+let pending = 0;
+sourceBox.oninput = () => {
+  const p = panes[which.value];
+  p.source = sourceBox.value;
+  clearTimeout(pending);
+  pending = setTimeout(() => build(p), 150);
 };
-function upload() {
-  object.meshes.forEach((m, i) => {
-    room(4 + m.vertices.length + m.faces.length);
-    program.set([FRAME_ASSET, handleBase + i, m.vertices.length / 3, m.count], length);
-    program.set(m.vertices, length + 4);
-    program.set(m.faces, length + 4 + m.vertices.length);
-    length += 4 + m.vertices.length + m.faces.length;
-  });
-  uploaded = true;
-}
+
+// ——— the frame program: CAMERA, a floor, the object ———
 const norm = (v) => { const m = Math.hypot(...v) || 1; return v.map((x) => x / m); };
 const cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
 // As FightCamDoll.prepare: world y points down, the lens looks at the axle.
@@ -177,72 +191,80 @@ function camera() {
   const forward = norm(target.map((t, i) => t - position[i]));
   const right = norm(cross(forward, [0, -1, 0])), up = norm(cross(right, forward));
   const width = 2 * state.dist * Math.tan(fov / 2);
-  room(25);
-  program.set([FRAME_CAMERA, ...position, ...right, ...up, ...forward, W / 2, H / 2, W / width,
+  return [...position, ...right, ...up, ...forward, W / 2, H / 2, W / width,
     W / (2 * Math.tan(fov / 2)), state.perspective, 2.8 / 16000, -1.4, 8,
-    -W * .5, W * 1.5, -H * .5, H * 1.5], length);
-  length += 25;
+    -W * .5, W * 1.5, -H * .5, H * 1.5];
 }
-// A treadmill floor: the object holds still and the tiles run under it.
-function floor(forward, side) {
+// A treadmill floor, flat at the back of the depth range so whatever stands
+// on it (and its shadow) covers it.
+function floor(p, forward, side) {
   const tile = 40, n = 8, shift = ((state.distance % (tile * 2)) + tile * 2) % (tile * 2);
   const [a, b] = [rgb(color("--line")), rgb(color("--bg"))];
+  p.push(FRAME_DEPTH, 1, 1.35);
   for (let i = -n; i < n; i++) for (let j = -n; j < n; j++) {
     const u0 = i * tile - shift, v0 = j * tile, c = (i + j) & 1 ? a : b;
     const at = (u, v) => [forward[0] * u + side[0] * v, 0, forward[2] * u + side[2] * v];
-    const p = [at(u0, v0), at(u0 + tile, v0), at(u0 + tile, v0 + tile), at(u0, v0 + tile)];
-    worldFace(...p[0], ...p[1], ...p[2], ...c);
-    worldFace(...p[0], ...p[2], ...p[3], ...c);
+    const q = [at(u0, v0), at(u0 + tile, v0), at(u0 + tile, v0 + tile), at(u0, v0 + tile)];
+    p.push(FRAME_WORLD, ...q[0], ...q[1], ...q[2], ...c, FRAME_WORLD, ...q[0], ...q[2], ...q[3], ...c);
   }
+  p.push(FRAME_DEPTH, 0, 0);
 }
 
-let last = performance.now(), tickUs = 0, numbers = 0, triangles = 0;
-function frame(now) {
-  const dt = Math.min(.05, (now - last) / 1000); last = now;
-  if (playing) {
-    state.time += dt; state.distance += state.speed * dt; state.hit += dt; state.land += dt;
-    if (state.distance > 2000 || state.distance < 0) state.distance = ((state.distance % 2000) + 2000) % 2000;
+let last = performance.now();
+function draw(p, view, forward, up, right) {
+  if (p.gl) p.gl.beginFrame(); else p.flat.faces.length = 0;
+  p.length = 0;
+  p.push(FRAME_CAMERA, ...view);
+  floor(p, forward, right);
+  p.vm.run(p.program, p.length, []);
+  // The object in a program of its own, so the counts are its alone.
+  p.length = 0;
+  if (p.object && !p.uploaded) {
+    p.object.meshes.forEach((m, i) =>
+      p.push(FRAME_ASSET, p.handleBase + i, m.vertices.length / 3, m.count, ...m.vertices, ...m.faces));
+    p.object.sketches.forEach((k, i) =>
+      p.push(FRAME_SHAPES, p.sketchBase + i, k.count, k.records.length, ...k.records));
+    p.uploaded = true;
   }
-  for (const show of shows) show();
-  const forward = [Math.cos(state.heading), 0, Math.sin(state.heading)];
-  const up = [0, -1, 0], right = cross(forward, up);
-  // Two programs: the floor, then the object, so the host's count is the
-  // object's alone.
-  if (gl) gl.beginFrame(); else flat.faces.length = 0;
-  length = 0;
-  camera();
-  floor(forward, right);
-  vm.run(program, length, []);
-  length = 0;
-  if (object && !uploaded) upload();
-  camera();
-  const before = length;
-  tick.faces = tick.models = 0;
-  if (object) {
+  p.push(FRAME_CAMERA, ...view);
+  const before = p.length;
+  p.tick = {};
+  p.out.view = view;
+  if (p.object) {
     const t = performance.now();
-    object(state, [0, -24, 0, ...forward, ...up, ...right], out);
-    tickUs = (performance.now() - t) * 1000;
+    p.object(state, [0, -24, 0, ...forward, ...up, ...right], p.out);
+    p.us = (performance.now() - t) * 1000;
   }
-  numbers = length - before;
-  hostTriangles = 0;
-  vm.run(program, length, []);
-  triangles = hostTriangles;
-  if (gl) {
-    gl.present({ clear: [...rgb(color("--panel")).map((v) => v / 255), 1] });
-  } else {
-    const { ctx } = flat;
+  p.numbers = p.length - before;
+  p.triangles = 0;
+  p.vm.run(p.program, p.length, []);
+  if (p.gl) p.gl.present({ clear: [...rgb(color("--panel")).map((v) => v / 255), 1] });
+  else {
+    const { ctx } = p.flat;
     ctx.fillStyle = color("--panel"); ctx.fillRect(0, 0, W, H);
     // Far first: the depth the game gives a face grows away from the lens.
-    flat.faces.sort((p, q) => (q[2] + q[5] + q[8]) - (p[2] + p[5] + p[8]));
-    for (const f of flat.faces) {
+    p.flat.faces.sort((a, b) => (b[2] + b[5] + b[8]) - (a[2] + a[5] + a[8]));
+    for (const f of p.flat.faces) {
       ctx.fillStyle = `rgb(${f[9]},${f[10]},${f[11]})`;
       ctx.beginPath(); ctx.moveTo(f[0], f[1]); ctx.lineTo(f[3], f[4]); ctx.lineTo(f[6], f[7]); ctx.fill();
     }
   }
-  document.getElementById("status").textContent =
-    `${gl ? "webgl, depth-tested" : "canvas, depth-sorted"} · a tick: ${tick.models} MODEL + ` +
-    `${tick.faces} WORLD = ${numbers} numbers, ${tickUs.toFixed(0)} µs · host drew ${triangles} triangles · ` +
-    `${object ? object.meshes.length : 0} baked meshes · compile ${compileMs.toFixed(1)} ms · inputs: ${objectInputs.join(" ")}`;
+  const ops = Object.entries(p.tick).map(([k, n]) => `${n} ${k}`).join(" + ");
+  document.getElementById(`${p.kind}Status`).textContent =
+    `a tick: ${ops || "nothing"} = ${p.numbers} numbers, ${p.us.toFixed(0)} µs · host drew ${p.triangles} triangles` +
+    (p.object?.meshes.length ? ` · ${p.object.meshes.length} baked meshes` : "") +
+    (p.object?.sketches.length ? ` · ${p.object.sketches.length} baked sketches` : "") + ` · ${p.gl ? "webgl" : "canvas"}`;
+}
+function frame(now) {
+  const dt = Math.min(.05, (now - last) / 1000); last = now;
+  if (playing) {
+    state.time += dt; state.distance += state.speed * dt; state.hit += dt; state.land += dt;
+    if (state.distance > 2000 || state.distance < 0) state.distance = ((state.distance % 2000) + 2000) % 2000;
+  }
+  for (const show of shows) show();
+  const forward = [Math.cos(state.heading), 0, Math.sin(state.heading)];
+  const up = [0, -1, 0], right = cross(forward, up), view = camera();
+  for (const p of Object.values(panes)) draw(p, view, forward, up, right);
   document.documentElement.dataset.ready = "1";
   if (!still) requestAnimationFrame(frame);
 }