RECIPE — JSON (what travels) copy

DIALECT — LUA PARAMS (what the engine consumes) copy

the Forge — a drafting table for Everdeep worlds ✕

One canvas, one recipe underneath. Formerly the CAD Lab. Esc closes this page.

ABOUT — WHY THIS TOOL EXISTS

The recipe IS the world. Nothing here paints blocks by hand. You edit a small, readable document — shapes, generators, rules, dress — and the engine's own generator expands it, deterministically, into a world. Same recipe + same seed = the same world on every machine, forever. That determinism turns worlds into messages: a whole cave is a ~2 KB cave code you can paste in a chat, and the identical world bakes on the other side. One code on a stream puts the entire audience in the SAME cave — fair challenges at any scale.

Engine-free, by design. The Forge never talks to a live engine. Truth is the ▦ Voxel view — the exact block lens: the engine's own FinishCell law on the exact field, with the game's real textures and per-block variant dice (the twin was measured at 100.0% conformance and 95.6%+ block-for-block before the live channel retired). The only road to the game is 💾 save → ⭢ Save local → game; then open the game and create a world by that name.

The hour-world goal. Everything here serves one bar: a creator goes from blank table to a world worth walking in about an hour. Built to Floris's three F's — Flexible (the dialect grows), Frictionless (boot→editing in seconds, one-click verbs), Fun (clay, knobs, instant feedback).

SHAPE — CLAY FIRST

• Add — two doors, same records: the ＋ shapes shelf arms a primitive (every ground click places one, sticky, Esc stops), or click empty ground for the context menu: sphere, box, cylinder, cone, pyramid, dune / mesa / rock (variant shapes — the inspector's 🎲 rerolls each one's character without moving it), and pillar pairs — a stalagmite meets a stalactite, tips touching: pillar (cones) is the round column, pillar (pyramids) the angular one. Each half is an ordinary object (own position, radius, height, material, rotation); both are selected at birth so the first drag moves the whole column. One bubble can be the main chamber (cave) — it compiles to the environment's size.
• The gizmo — ONE transform gizmo at the selection's centroid, every kind of object: W move (axis arrows + gold ground-plane center) · E scale (axis handles + gold uniform center) · R rotate (green Y ring always; red/blue pitch/roll rings when every member supports them). Rotation always pivots at the gizmo center — with tips lock (L) on, a lone cone/pyramid pivots about its welded tip (apex) instead, so a leaned pillar half swings its base while the meeting point stays met; groups rotate about the shared centroid. Ctrl snaps: 0.05 grid, 15°, ×0.05 scale. Semantic knobs stay separate: tunnel/maze ports, width midpoints, seam blend. Knobs hold constant screen size at any zoom.
• Multi-select — Ctrl+click toggles any object in and out of the selection set, mixed kinds welcome. The gizmo moves the group by a shared delta, orbits it about the centroid, scales positions + sizes from it; the group card applies a material to all or deletes all (Del). Body drag of the anchor moves the whole set.
• Repeat along a guide — with a selection live, the inspector / group card offers ⋯ repeat along line and ⟳ repeat in circle: draw the guide (two clicks), ghosts appear, then tune live — wheel or +/− = count (2..40) · drag the gold ends = spacing · R = follow the curve vs keep orientation · chip slider = seeded jitter (position + ±15% size) · 🎲 varied = fresh variant seed per copy. Enter or click away COMMITS: the guide dissolves and N real individual objects land (batch selected, one Ctrl+Z removes it); Esc cancels clean. The unit is the whole selection — mixed kinds, pillar pairs, tunnels between copied shapes ride along; the maze is a singleton and stays home. Guides are gestures: nothing group-like survives the commit.
• Roles — Solid (matter) · Hollow (a shell with wall thickness — a cave in one object; the shell BAKES as a shell) · Carve (negative space, bites out of overlaps).
• Blend & seam — per-object blend smooths how a shape melts into neighbors; the seam knob between touching shapes tunes one junction.
• Surface & relations (inspector) — three text fields under IDENTITY, all engine-op twins: surface = a per-object roughness stack, layers joined by ; — syntax n:freqX,freqY,freqZ:ampX,ampY,ampZ for noise, s:… for directional skew, units in world blocks (the HUD wears surface≈ while any object carries one: the clay shows the character, the engine's dice bake the exact grain). within # = keep only the part of this object inside object #n (Intersection; numbers are the 1-based draft order). apron # k = melt this object INTO object #n over k blocks (SmoothIntoShape) — sand climbing a cliff.
• Inside mode — double-click a hollow shape (or its inspector's ⇲ step inside) to step INSIDE the room and furnish it. While inside: the shell stops selecting (clicks pass through it), the near wall clips away so the interior reads, placement clicks land on the room's own floor/walls/ceiling (a cone placed on the ceiling flips and hangs), and gizmo moves stop at the inner wall — only CENTERS are confined, bulk may still melt into the shell. Everything else works as normal: add shelf, factories, repeat guides, materials, undo, copy/paste. Esc or the ⌂ chip's ✕ steps out; the camera returns to where it was. Moving the room itself (from outside): rubber-band the room + its contents and drag once.
• Tunnels & ports — drag a shape's outer knob onto another shape to grow a corridor. A tunnel's midpoint knob selects it (Del removes, Alt-click = instant remove). Width and wind live in the inspector.

GENERATORS — RULES IN, TERRAIN OUT

The twin law in one sentence: every generator runs the SAME math here and in the engine, so the preview on this table IS the layout the bake produces — same seed, same world, forever.

• Ravine field — a FACTORY too (v3.12): ⚡ drops N individual snaking gorges cutting down from the tallest solid (give them a terrain slab). Each ravine is ONE carve object — move it, spin it (rot = its heading), scale width/depth, edit its length knob, 🎲 re-snake its wander, Del it. Exploded legacy fields keep their starts/headings/depths; the wander re-seeds.
• Maze — one entry (west), N exits, difficulty = dead-end density. Exit knobs are PORTS: drag an exit onto a shape and a corridor links them (Alt-click the knob removes the link). The 🎲 seed gallery shows six sibling labyrinths — click one to adopt it.
• Dune / plateau fields — FACTORIES (v3.12): the panel's knobs set the layout law, ⚡ runs it ONCE and drops N individual dunes/mesas on the table (Anton's law: each item produced is an individual item in the editor). From then on each item is an ordinary object — its own gizmo, inspector numbers, material, 🎲 variant seed, Del. The batch lands selected, so one Del undoes it; 🎲+⚡ rolls another layout. No live field record survives; legacy recipes with old field records explode into the same objects on load.

DRESS — MATERIALS, EXACT AND ≈

• Library — 🗄 all… opens every texture set the game ships; the preview cube wears a hovered tile with its real normal + roughness maps under light. Gold ring = a registered block: it BAKES. Others texture the Forge views only.
• Per-object materials BAKE — a material on a shape/maze travels in the dialect and the engine builds it. Undressed objects inherit the scene wall material.
• Scene dress (view pop): ore — glow pockets sprinkled through walls (≈ estimate: the engine's random stream arbitrates the exact cells) · floor — paints up-facing walls, exact · scatter/hangings — growth on floors/ceilings by chance per block (≈) · rough — engine-side surface noise (Anubis ≈ 3) · twist — whole-cave corkscrew · floor cut — slice everything to a walkable plane. Rough/twist/floor-cut are LIVE twins (exact); growth and ore roll at bake.

ASSETS — PLACE THE FURNITURE

• Placement — the ASSETS tab of the library arms a blueprint; every click drops one (Esc stops). The engine floor-snaps each onto the real baked floor.
• Facing — double-click a placed asset to rotate it 90° (N→E→S→W); the facing bakes.
• Patterns — one rule places many: ring / square / voronoi / row of structures, or a hidden pattern of ore the player has to read from the walls. Click distance from center = radius; a row takes two clicks (start, then end) and its items face perpendicular to the line. Alt-click a spike removes the arrangement.
• Navigate — n (or ⌖ next) flies the camera to each placement in turn.

VERIFY & TRUTH — ENGINE-FREE

The Forge is fully decoupled from a live engine (2026-07-14, Anton: "No more push pull. The only way to get to the game is to save the file."). This table holds the DRAFT; the game gets it one way only: 💾 save → ⭢ Save local → game, then create a world by that name in the game.

B cycles THREE views of one recipe: ◇ Primitive (the editable scaffold) → ◆ Clay (the exact scene SDF, sphere-traced per pixel) → ▦ Voxel (the SAME field through the block lens — sample points snapped to the bake lattice, FinishCell law, materials + variants live). The Voxel view IS the truth here: the engine's own geometry law with the game's own textures and variant dice, and views never write. Local truth tools: ⚑ playability lint — flood-fills the maze and flags exits that quantize shut · 🚶 walk the clay — stand inside the exact field at true player scale · cutaway — slice the view open, free knob, never bakes. The old live-engine instruments (⚖ conformance, ✓ block-for-block, 🔥 heat, 🧊 walk the engine) retired with the channel; the publish pipeline's fail-closed gates inherit their job at save time.

The thin wireframe box is the CELL — an ownership line, not a clamp. It turns amber when anything crosses; whatever crosses gets trimmed. Design inside.

RAY CLAY — THE THREE-VIEW LAW

The raymarcher is the ONLY clay renderer (mesh clay retired 2026-07-14): it sphere-traces the exact scene SDF per pixel on the GPU — no grid, no res knob, no freeze guard — thin shells render true, and edits land the same frame. Variants (dune/mesa/rock/ravine), tunnels and maze corridors are exact twins of the local SDF (verified to ~3e-8).

• Three views, three jobs. B cycles ◇ Primitive = the SCAFFOLD (shapes, knobs, gizmos) → ◆ Clay = pure FORM (the ray march) → ▦ Voxel = the BLOCKS. The Forge never simulates blocks: the Voxel view is the same march with sample points snapped to the bake lattice — zero engine involvement, zero rebuild, live under every gizmo drag. The geometry law is the engine's own (FinishCell: a cell is matter iff the field is negative at its center — grid-traversed, cell centers evaluated exactly); twist and floor cut ride along as matter laws; materials and variant character render live; dress noise/roughness is the engine's dice and rolls at bake (the HUD says so). The lens is the live preview of what Save local → game will quantize.
• Engine truth moved into the publish gate. The live-engine instruments (⚖ / ✓ / 🔥 / 🧊) retired with the ws channel; the publish pipeline's scoped bake, measured spawn and fail-closed walkability gate answer for the real engine now, at save time. Views never write; saving is your verb.
• Honesty notes. rough≈: clay's roughness is the same value-noise character at true scale but a different random stream than the engine's — thin walls really do erode, exact grain differs. The same law covers per-object surface stacks: the HUD wears surface≈ whenever one is in play. A selected variant golds ALL its sub-blobs (parent identity — sub-blobs never pick individually).
• The FPS chip (top right) is the honest meter: cached = frames are blits of the last march (display rate); march N ms = the field or camera changed and the GPU re-traced, ×0.nn res = motion/heavy-vantage marches drop internal resolution and refine back to full at rest; edit→frame = your last edit's latency to pixels. Over budget (2048 prim rows), the march refuses and a toast says so — sculpt in sections or slim the draft.

SCALE — SIZE BUYS DETAIL

• bake @ — the resolution the ▦ Voxel lens shows and the recipe carries to Save local → game. Engine blocks are fixed size, so real detail comes from real size: ⤢ 2× the design (design pop) rather than wishing for finer blocks.
• No clay res knob — the raymarcher has no grid: the Clay and Voxel views are exact at every zoom, and the only resolution that exists is the engine's own bake @.
• Per-axis radii (v3.14) — every shape now carries a third radius: width (rh, X), height (rv, Y) and depth (rz, Z). The red and blue scale knobs drive width and depth INDEPENDENTLY; the gold center scales all three. Ellipsoids and boxes take it natively at the engine (NewEllipsoid/NewBox are per-axis); cylinders, cones, pyramids and the dune/mesa/rock composites ride the engine's own anisotropic Scale op in the shape's local frame. Two honest fences: the ravine keeps its own rot/length grammar (one footprint knob), and the Cave travels as scalar params.size. Older docs without rz load byte-identical (rz = width). One approximation: the room-focus CUT plane approximates a spun (rotated) oval room by its unrotated ellipsoid — selection, placement and moves use the true SDF and are exact.

SHARE — WORLDS AS MESSAGES

• ⧉ Cave codes — the whole recipe as an EVD1. string (~2 KB). Paste anywhere, identical cave.
• The world IS the string — and the string has four bodies now: copy it (⧉ code), file it (💾 .evd — 📂 open loads it back, or just drop the file on the canvas), QR it (▣ renders the code as a scannable image with a download-PNG button), read it back (⇪ QR in decodes a PNG/JPG — a screenshot or a photo of a screen — or drop the image on the canvas). Message someone the QR; they drop it into their Forge and stand in your world. All of it is pure string work — the engine can be offline. Codes past QR capacity (2953 chars, v40 EC L) say so honestly and travel as .evd instead.
• Fragments — parts travel as EVDF. strings: Ctrl+C copies the selection set (shapes and the tunnels between them — materials included) to the clipboard, Ctrl+V pastes it (+0.15 offset, pasted set selected), Ctrl+D duplicates in place. Dunes/mesas/rocks travel like any shape — the maze singleton pastes only onto a table without one.
• ☁ Save to Keep — the 💾 save pop's first destination (same flow as ☁ library save): versioned recipes in the assets catalog (sign in once; the browser never holds keys). Autosave keeps a local crash copy always.
• { } code view — the recipe JSON and the dialect Lua it compiles to, live. No hidden state.
• 💾 Save local → game — export to a playable world. The 💾 save pop's second destination bakes the draft into a REAL game world: name it in the dialog (the name shows in the game's world-template list; the night-vision checkbox lights the review walk), then a region-scoped bake, a measured spawn and a fail-closed walkability gate run before anything is published. Small builds land in ~30 seconds; then create a NEW world with that name in the game. A selected object becomes the spawn hint — you land next to it.

SHORTCUTS — ALL OF THEM

B view cycle — Primitive → Clay → Voxel → Primitive (the Voxel view IS the block lens: blocks at the current bake @, zero engine involvement) · W/E/R gizmo mode: move / scale / rotate · Ctrl+click toggle an object in the selection set · Ctrl+drag from empty ground = rubber-band box (its objects join the set) · Ctrl+C/V/D copy / paste / duplicate the set (EVDF. fragments) · repeat guides (armed): wheel or +/− count · R follow/keep · Enter/click-away commit · Esc cancel · n navigate to next placement · double-click a hollow shape = step INSIDE it (Esc steps out) · Del delete the selection (single or the whole set) · Ctrl+Z undo (Ctrl+Y redo) — the settled-draft snapshot stack · Esc close one thing: placement → popups → panels → selection · Ctrl+gizmo drag snaps (0.05 grid / 15° / ×0.05 scale) · Alt-click removes a tunnel, maze link, asset, or arrangement · double-click empty = camera home; still-click an asset = rotate facing · click empty ground = add menu · outer knob = drag a tunnel · midpoint knob = select a tunnel.

HONEST CONCERNS — READ BEFORE TRUSTING

• Engine versioning & drift. A recipe is data; the template that interprets it ships with the engine. An engine upgrade can change what the same recipe bakes (new template, changed ops, changed noise). Recipes don't yet carry a dialect version stamp, and there is no compatibility gate on load. Mitigation today: after an engine update, republish (Save local → game) and review-walk the world; a changed bake means drift. Planned: version stamp in the recipe + a migration note on open.
• The lens is geometry-exact, dress is ≈. The ▦ Voxel view runs the engine's own FinishCell law on the exact field, but the engine's detail passes (noise, growth, ore) roll their own dice at bake — the surface band and dressing can differ. The published world is the arbiter.
• Code-tier content is invisible to local math. Arrangements and sketches bake, but the local field and the cull can't see them — trust { } and the published world for those.
• Chunk slop past the cell. The bake writes whole chunks, so matter can survive up to a quarter-cell beyond the bounds box depending on seed — never rely on it; the guarantee line is the box.
• Cloud recipes need a sign-in. Save/open to the Keep wants your creator account (once, browser-held); offline you still have the local autosave crash net and cave codes.

Everything above is enforced or measured, not aspirational: the law is code, the lens is the bake's own law, and the publish gate is fail-closed.