@maniclang/workbench 0.1.11

package/examples/gradient.manic

@@ -0,0 +1,74 @@
+// Gradient paint — the color is computed, not painted.
+//   manic examples/gradient.manic
+//   manic examples/gradient.manic --still 11 --scale 1.5
+//
+// One word, five truths (stops ≥ 2, evenly spaced; mode optional):
+//   gradient(path, c1, c2)                 arc-length along a stroke
+//   gradient(plot, c1, c2, c3, 270)        linear over the bounds — height, any number of stops
+//   gradient(shape, c1, c2, radial)        centre → edge
+//   gradient(traj, c1, c2, "speed")        a trajectory colored by its true local speed
+//   gradient(path, c1, c2, "curvature")    any path colored by how hard it bends
+
+title("Gradient Paint");
+canvas(1280, 720);
+template("blank");
+
+// --- cast ---
+
+// a radial "energy well" behind everything
+circle(well, (640, 400), 260);
+filled(well);
+gradient(well, panel, void, radial);
+opacity(well, 0.85);
+
+// a plot colored by its own height, in three stops: blue low, cyan mid, gold high.
+// The vertical linear gradient over the curve's bounds IS its y-value.
+axes(ax, (640, 400), 520, 220);
+plot(wave, (640, 400), 78, 150, sin, 6.6);
+stroke(wave, 4);
+gradient(wave, blue, cyan, gold, 270);
+untraced(wave);
+
+// a curve colored by its own curvature — the tight apex carries the color
+spline(swoop, (160, 640), (400, 260), (640, 160), (880, 260), (1120, 640));
+stroke(swoop, 5);
+gradient(swoop, dim, magenta, "curvature");
+untraced(swoop);
+
+// an RK4 free kick (top-down pitch) colored by its true speed —
+// gold off the boot, blue as drag bites (slowest stop first, fastest last)
+freekick(kick, (185, 690), 30, 36, 3.5, 5.5, 120);
+stroke(kick, 5);
+gradient(kick, blue, gold, "speed");
+untraced(kick);
+hidden(kick.ball);
+
+// an arrow whose head takes the gradient's tip color
+arrow(dart, (420, 600), (1040, 600));
+stroke(dart, 4);
+gradient(dart, dim, lime);
+untraced(dart);
+
+// headline + caption
+text(head, (640, 100), "the color is computed, not painted");
+display(head);  color(head, cyan);  size(head, 30);  hidden(head);
+text(cap, (640, 680), "");  color(cap, dim);  size(cap, 22);
+
+// --- script ---
+
+show(head, 0.5);
+say(cap, "a height-colored plot: blue low, cyan mid, gold high");
+draw(wave, 1.8);
+wait(0.6);
+
+say(cap, "a curve colored by its own curvature — the bend glows");
+draw(swoop, 1.6);
+wait(0.6);
+
+say(cap, "a free kick colored by its true speed — gold fast, blue slow");
+draw(kick, 1.6);
+wait(0.6);
+
+say(cap, "an arc-length stroke; the arrowhead takes its tip color");
+draw(dart, 1.2);
+wait(1.2);

package/examples/graph.manic

@@ -0,0 +1,45 @@
+// Graph — the algo kit's `graph` builtin (Manim's Graph/DiGraph). Nodes are
+// labelled circles; `a-b` is an undirected edge, `a>b` a directed arrow. Tag
+// broadcast (`draw(g.edges)`, `flash(g.nodes, …)`) animates whole groups.
+//
+//   manic examples/graph.manic
+//   manic examples/graph.manic --record out --fps 60
+
+title("Graph");
+canvas(1280, 720);
+
+text(head, (640, 118), "a directed graph, traversed");
+display(head);  color(head, cyan);  size(head, 34);  hidden(head);
+text(cap, (640, 664), "");  color(cap, dim);  size(cap, 22);
+
+// six vertices in a circle; directed edges (a>b)
+graph(g, "a b c d e f",
+         "a>b b>c c>d d>e e>f f>a a>d b>e",
+         circular, (640, 384), 210);
+
+// nodes fade in (hidden→show); edges trace on (untraced→draw)
+hidden(g.nodes);
+untraced(g.edges);
+
+show(head, 0.5);
+say(cap, "drop in the vertices");
+show(g.nodes, 0.4);            // broadcasts over every node
+say(cap, "connect the directed edges");
+draw(g.edges, 0.6);           // broadcasts over every edge
+
+section("Traversal");
+say(cap, "walk a > b > c > d");
+seq {
+  flash(g.a, magenta);
+  flash(g.b, magenta);
+  flash(g.c, magenta);
+  flash(g.d, magenta);
+}
+say(cap, "highlight the visited path");
+par {
+  recolor(g.a, lime, 0.4);
+  recolor(g.b, lime, 0.4);
+  recolor(g.c, lime, 0.4);
+  recolor(g.d, lime, 0.4);
+}
+wait(1.2);

package/examples/graph_moving.manic

@@ -0,0 +1,67 @@
+// Moving Graph — vertices move and the edges reflow to follow them
+// (Manim's MovingVertices / MovingDiGraph). Also exercises layout reveal,
+// per-node moves, tag-broadcast recolour, and a highlight sweep.
+//
+//   manic examples/graph_moving.manic
+//   manic examples/graph_moving.manic --record out --fps 60
+//
+// Node ids are g.1 … g.4 ; edge ids g.1-2 etc ; tags g.nodes / g.edges.
+
+title("Moving Graph");
+canvas(1280, 720);
+
+text(head, (640, 118), "edges follow their vertices");
+display(head);  color(head, cyan);  size(head, 34);  hidden(head);
+text(cap, (640, 664), "");  color(cap, dim);  size(cap, 22);
+
+// four vertices, five undirected edges, circular to start
+graph(g, "1 2 3 4", "1-2 2-3 3-4 1-3 1-4", circular, (640, 384), 150);
+hidden(g.nodes);
+untraced(g.edges);
+
+// --- reveal ---
+show(head, 0.5);
+say(cap, "a small graph");
+show(g.nodes, 0.4);
+draw(g.edges, 0.6);
+wait(0.5);
+
+// --- case 1: fling the vertices to the corners; edges reflow live ---
+section("Moving vertices");
+say(cap, "move each vertex — the edges stretch to follow");
+par {
+  move(g.1, (360, 250), 1.2, overshoot);
+  move(g.2, (920, 250), 1.2, overshoot);
+  move(g.3, (920, 520), 1.2, overshoot);
+  move(g.4, (360, 520), 1.2, overshoot);
+}
+wait(0.8);
+
+// --- case 2: orbit two vertices past each other ---
+say(cap, "swap two vertices");
+par {
+  move(g.2, (360, 520), 1.0, smooth);
+  move(g.4, (920, 250), 1.0, smooth);
+}
+wait(0.8);
+
+// --- case 3: pull one vertex around; incident edges track it ---
+say(cap, "drag one vertex around");
+seq {
+  move(g.1, (640, 150), 0.7, smooth);
+  move(g.1, (1080, 384), 0.7, smooth);
+  move(g.1, (640, 620), 0.7, smooth);
+  move(g.1, (360, 250), 0.7, smooth);
+}
+wait(0.6);
+
+// --- case 4: recolour the whole graph via tag broadcast, then highlight ---
+section("Styling");
+say(cap, "recolour every edge, then highlight a node");
+recolor(g.edges, cyan, 0.5);
+flash(g.1, magenta);
+par {
+  recolor(g.1, lime, 0.4);
+  pulse(g.1);
+}
+wait(1.5);

package/examples/grid-astar.manic

@@ -0,0 +1,15 @@
+title("A* Pathfinding — Search Over Space");
+canvas("16:9");
+template("neon");
+
+watermark(mark, (w*0.15, h*0.05), "Made With Manic");
+
+// A cell grid seeded from a compact ASCII maze: `#` wall, `.` open, `@` start,
+// `*` goal. A* explores the open cells (frontier cyan → current magenta), then
+// the shortest route is traced in gold — the spatial sibling of the algo kit's
+// graph search, sharing its exact colour grammar.
+grid(g, "@ . . . . . . . ; # # # # # # . # ; . . . . . . . . ; . # # # # # # # ; . . . . . . . . ; # # # # # # # *", (cx, cy+20), 8, 6, 78);
+neighbors(g, "4");
+
+gridastar(g, (0,0), (7,5), manhattan);
+draw(g.path, 1.4);

package/examples/grid-life-soup.manic

@@ -0,0 +1,31 @@
+// grid-life-soup — Conway's Game of Life from a random soup, on the grid kit.
+//
+// A 40x40 cellular automaton seeded with a pseudo-random field (manic has no
+// rand(), so a shader-style hash stands in), then evolved: each
+// `evolve(life,"life")` pre-simulates one Conway generation at build time
+// (alive = a filled `wall` cell, B3/S23, 8-neighbourhood), and `run` replays
+// the 30 stored generations — the soup settles into gliders, blinkers and still lifes.
+//
+//   manic examples/grid-life-soup.manic
+title("Conway's Life — a random soup");
+canvas(1080, 1080);
+template("paper");
+
+let cols = 40;
+let rows = 40;
+let cell = 25;
+grid(life, (540, 540), cols, rows, cell);
+
+// seed ~45% of cells at random — `random` is deterministic, so the soup is
+// reproducible; render with `--seed random` to roll a fresh soup each time.
+for r in 0..rows {
+  for c in 0..cols {
+    if random(r, c) > 0.55 {
+      setcell(life, r, c, wall);
+    }
+  }
+}
+
+// pre-simulate 30 generations, then replay them over 8s
+for g in 0..30 { evolve(life, "life"); }
+run(life, 30, 8);

package/examples/grid-life-zoo.manic

@@ -0,0 +1,46 @@
+// Conway's Life — the Zoo. img_4.png's taxonomy (still lifes / oscillators /
+// spaceships) is nothing more than Conway's Life on a grid — which the grid kit
+// already does: seed cells, `evolve` a few generations at build time, then `run`
+// to replay them. Three grids run in parallel: a Block that never moves, a Blinker
+// that oscillates, and a Glider that walks across its grid. No new kit needed.
+title("Conway's Life — the Zoo");
+canvas("16:9");
+template("mono");
+
+let u = (w+h-abs(w-h))/1440;
+text(kicker, (cx, h*0.10), "STILL LIFE · OSCILLATOR · SPACESHIP — all just Conway's Life");
+size(kicker, 22*u); color(kicker, dim); bold(kicker); wrap(kicker, w*0.9);
+
+// --- Still life: Block (never changes) ---
+grid(blk, (w*0.22, cy), 6, 6, 40);
+setcell(blk, 2, 2, wall); setcell(blk, 2, 3, wall);
+setcell(blk, 3, 2, wall); setcell(blk, 3, 3, wall);
+text(blkL, (w*0.22, cy+180*u), "Block — still life"); size(blkL, 20*u); color(blkL, cyan);
+
+// --- Oscillator: Blinker (period 2) ---
+grid(bln, (w*0.5, cy), 6, 6, 40);
+setcell(bln, 2, 1, wall); setcell(bln, 2, 2, wall); setcell(bln, 2, 3, wall);
+text(blnL, (w*0.5, cy+180*u), "Blinker — oscillator (p2)"); size(blnL, 20*u); color(blnL, cyan);
+
+// --- Spaceship: Glider (translates) ---
+grid(gld, (w*0.78, cy), 8, 8, 34);
+setcell(gld, 1, 2, wall);
+setcell(gld, 2, 3, wall);
+setcell(gld, 3, 1, wall); setcell(gld, 3, 2, wall); setcell(gld, 3, 3, wall);
+text(gldL, (w*0.78, cy+180*u), "Glider — spaceship"); size(gldL, 20*u); color(gldL, cyan);
+
+// Pre-simulate 8 generations of each (build time), same count so they replay in sync.
+evolve(blk, "life"); evolve(blk, "life"); evolve(blk, "life"); evolve(blk, "life");
+evolve(blk, "life"); evolve(blk, "life"); evolve(blk, "life"); evolve(blk, "life");
+evolve(bln, "life"); evolve(bln, "life"); evolve(bln, "life"); evolve(bln, "life");
+evolve(bln, "life"); evolve(bln, "life"); evolve(bln, "life"); evolve(bln, "life");
+evolve(gld, "life"); evolve(gld, "life"); evolve(gld, "life"); evolve(gld, "life");
+evolve(gld, "life"); evolve(gld, "life"); evolve(gld, "life"); evolve(gld, "life");
+
+// Replay all three at once — the whole zoo, self-animating.
+par {
+  run(blk, 8, 5.0);
+  run(bln, 8, 5.0);
+  run(gld, 8, 5.0);
+}
+wait(0.6);

package/examples/grid-life.manic

@@ -0,0 +1,19 @@
+title("Conway's Life — A Glider");
+canvas("16:9");
+template("neon");
+
+watermark(mark, (w*0.15, h*0.05), "Made With Manic");
+
+// A cellular automaton on the same cell grid. `step` pre-simulates one Conway
+// generation at build time (alive = a filled `wall` cell, 8-neighbourhood);
+// `run` then replays the stored generations. This glider walks diagonally.
+grid(life, (cx, cy+10), 14, 12, 42);
+setcell(life, 1, 2, wall);
+setcell(life, 2, 3, wall);
+setcell(life, 3, 1, wall);
+setcell(life, 3, 2, wall);
+setcell(life, 3, 3, wall);
+
+evolve(life, "life"); evolve(life, "life"); evolve(life, "life");
+evolve(life, "life"); evolve(life, "life"); evolve(life, "life");
+run(life, 6, 5.0);

package/examples/grid-wfc.manic

@@ -0,0 +1,13 @@
+title("Wave Function Collapse — A Maze, Settling");
+canvas("16:9");
+template("neon");
+
+watermark(mark, (w*0.15, h*0.05), "Made With Manic");
+
+// `collapse` pre-simulates a seeded Wave-Function-Collapse-style settling at
+// build time — each cell is decided under its neighbours' constraints, one row
+// at a time — then `run` replays the grid resolving from empty to a finished
+// maze. Seeded, so it is fully deterministic (same seed ⇒ same maze).
+grid(mz, (cx, cy+10), 20, 14, 30);
+collapse(mz, "maze", 7);
+run(mz, 14, 5.0);

package/examples/growing-fractal-tree3.manic

@@ -0,0 +1,58 @@
+title("One Rule Grows a Forest");
+canvas("9:16");
+template("blank");
+
+watermark(mark,(w*0.16,h*0.055),"Made With Manic");
+text(kicker,(cx,h*0.085),"FRACTAL TREE · BATCHED GENERATIONS");
+text(headline,(cx,h*0.13),"How can one branch become 1,023?");
+text(caption,(cx,h*0.84),"Repeat one rule: split, turn, shrink—and keep every generation readable.");
+text(cta,(cx,h*0.91),"CREATE YOUR OWN → 8gwifi.org/manic");
+size(kicker,20); color(kicker,dim); bold(kicker); hidden(kicker);
+size(headline,34); bold(headline); wrap(headline,w*0.84); hidden(headline);
+size(caption,22); color(caption,dim); wrap(caption,w*0.82); hidden(caption);
+size(cta,22); color(cta,cyan); bold(cta); hidden(cta);
+
+camera3((9,-13,8),(0,0,3.2),43);
+tree3(tree,(0,0,-3.2),2.1,27,0.72,10,42);
+for i in 0..10 { untraced(tree.d{i}); hidden(tree.d{i}); }
+hidden(tree.leaves);
+
+step("the seed") {
+  show(kicker,0.3); show(headline,0.45); show(caption,0.4);
+  view3(tree,"isometric",0.7,smooth,1.42);
+}
+wait(0.35);
+
+step("grow by generation") {
+  par {
+    stagger(0.16) {
+      for i in 0..10 {
+        par { show(tree.d{i},0.22); draw(tree.d{i},0.58,smooth); }
+      }
+    }
+    say(caption,"Each depth is one renderer batch, even when it contains hundreds of branches.",0.45);
+    view3(tree,"isometric",1.1,smooth,1.48);
+  }
+}
+wait(0.4);
+
+step("find the canopy") {
+  par {
+    show(tree.leaves,0.65);
+    seq {
+      orbit3(42,24,21.0,2.1,smooth);
+      view3(tree,"isometric",0.9,smooth,1.42);
+    }
+    say(caption,"A semantic camera journey reveals the rule first, then the whole canopy.",0.45);
+  }
+}
+wait(0.5);
+
+step("takeaway") {
+  par {
+    pulse(tree.leaves,0.7);
+    say(caption,"Deep procedural geometry stays simple to author, deterministic, and smooth to seek.",0.45);
+    show(cta,0.45);
+  }
+}
+wait(1.3);

package/examples/gun-shot.manic

@@ -0,0 +1,82 @@
+// ============================================================================
+//  gun-shot.manic  —  a scene, not a lesson. No physics kit, just imagination.
+// ----------------------------------------------------------------------------
+//  A gun fires · the camera races along with the bullet · a block drops in out
+//  of nowhere · BOOM. Built entirely from base manic — shapes, `move`, `cam`/
+//  `zoom` to fly the camera, `flash`/`shake`/`pulse`, and a `for`-loop spark
+//  burst. This is manic as a storytelling language: dream a scene, write it.
+// ============================================================================
+
+title("Gun Shot");
+canvas("16:9");
+
+// ---- the world (wide — the camera pans across it) ----
+line(ground, (-300, 560), (2400, 560)); color(ground, dim); stroke(ground, 4);
+
+// the gun: barrel + body + grip
+rect(barrel, (250, 470), 96, 22); color(barrel, dim); filled(barrel);
+rect(body, (206, 478), 52, 42); color(body, dim); filled(body);
+polygon(grip, (186, 500), (220, 500), (212, 554), (180, 550), dim);
+
+// the bullet at the muzzle, and a muzzle flash — both waiting
+circle(bullet, (302, 470), 12); color(bullet, gold); glow(bullet, 2.2); hidden(bullet);
+circle(mflash, (312, 470), 30); color(mflash, gold); glow(mflash, 3.5); hidden(mflash);
+
+// the block — waiting above, off-screen, to drop in ahead
+rect(block, (1750, 250), 130, 130); color(block, cyan); filled(block); glow(block, 1.4); hidden(block);
+text(boom, (1750, 320), "BOOM!"); size(boom, 96); color(boom, magenta); bold(boom); glow(boom, 2.5); display(boom); hidden(boom);
+
+// a ring of impact sparks around the block (revealed at the hit)
+for i in 0..14 {
+  let ang = i * tau / 14.0;
+  line(spark{i}, (1700, 470), (1700 + 160*cos(ang), 470 + 160*sin(ang)));
+  color(spark{i}, gold); stroke(spark{i}, 5); glow(spark{i}, 2); untraced(spark{i}); tag(spark{i}, sparks);
+}
+
+// a caption pinned to the screen (rides along through the camera move)
+text(cap, (cx, h - 56), ""); color(cap, fg); size(cap, 26); bold(cap); display(cap); sticky(cap);
+
+// ================= THE SCENE =================
+cam((440, 380), 0.4, smooth);          // frame the gun
+say(cap, "steady…", 0.4);
+wait(0.6);
+
+// FIRE!
+say(cap, "FIRE!", 0.2);
+par { show(mflash, 0.06); pulse(mflash); show(bullet, 0.08); }
+fade(mflash, 0.3);
+
+// the bullet races off — the camera flies with it — and mid-flight, out of
+// nowhere, a block slams down into its path
+par {
+  move(bullet, (1690, 470), 2.6, smooth);
+  cam((1560, 380), 2.6, smooth);
+  zoom(1.15, 2.6, smooth);
+  seq {
+    wait(1.5);
+    say(cap, "…wait — what's THAT?!", 0.3);
+    show(block, 0.1);
+    move(block, (1750, 470), 0.4, bounce);
+  }
+}
+
+// BOOM — impact
+say(cap, "BOOM!", 0.15);
+par {
+  flash(block, gold);
+  shake(block, 0.5);
+  zoom(1.5, 0.15);
+  show(boom, 0.12); pulse(boom);
+  draw(sparks, 0.35);
+}
+wait(0.5);
+
+// settle — pull back
+par {
+  fade(sparks, 0.5);
+  fade(boom, 0.6);
+  fade(bullet, 0.4);
+  zoom(1.0, 0.9, smooth);
+}
+say(cap, "…scene.", 0.4);
+wait(0.8);

package/examples/hashmap.manic

@@ -0,0 +1,38 @@
+// Hash Map — separate chaining. `hashmap(id, n, (cx,cy))` draws n numbered
+// buckets in a column; `put(id, key, val)` hashes the key to a bucket and chains
+// the `key:val` entry on (collisions extend the chain); `get(id, key)` hashes,
+// then scans that bucket's chain — each entry flashes until the key matches
+// (lime) or the chain ends (bucket flashes magenta = miss).
+//
+// (Hash = sum of the key's bytes mod n. "cat" and "act" are anagrams, so they
+//  collide — same bucket, chained.)
+//
+//   manic examples/hashmap.manic
+
+title("Hash Map");
+canvas("16:9");
+
+text(head, (cx, 60), "separate chaining: hash the key, chain on collision");
+display(head);  color(head, cyan);  size(head, 26);  hidden(head);
+text(cap, (cx, 690), "");  color(cap, dim);  size(cap, 24);
+
+hashmap(ht, 5, (360, 360), 128, 46);
+
+show(head, 0.5);
+say(cap, "put cat, dog, ok — each hashes to its bucket");
+put(ht, "cat", "7");
+put(ht, "dog", "3");
+put(ht, "ok", "1");
+wait(0.5);
+
+section("Collision");
+say(cap, "put act — same bytes as cat, so it collides and chains on");
+put(ht, "act", "9");
+wait(0.6);
+
+section("Lookup");
+say(cap, "get act — scan the chain in bucket 2 until the key matches");
+get(ht, "act");
+say(cap, "get xyz — hashes to a bucket, scans, falls off the end: miss");
+get(ht, "xyz");
+wait(1.2);

package/examples/heightmap3-world.manic

@@ -0,0 +1,64 @@
+// From Flat Map to 3D World — the creative payoff of the Grid→3D bridge. A grid-kit
+// Wave Function Collapse settles a map in 2D; then the very same grid is lifted by
+// heightmap3 into a 3D terrain that rises as the camera tilts down. One grid, two
+// dimensions — the grid kit never learns about 3D.
+title("From Flat Map to 3D World");
+canvas("16:9");
+template("neon");
+
+let u = (w+h-abs(w-h))/1440;
+watermark(mk, (w*0.86, h*0.06), "Made With Manic");
+
+// The 2D map (grid kit): a seeded WFC settle.
+grid(world, (cx, cy), 20, 16, 30);
+collapse(world, "maze", 11);
+
+// The 3D terrain from the SAME grid — near top-down at first, so it reads flat like
+// the map, then the tilt reveals its height. Hidden until the lift.
+camera3((0, -1.6, 20), (0, 0, 0), 24);
+heightmap3(land, world, "h*1.9 + fbm(x*1.2, y*1.2)*0.9 + 0.1", 8);
+color(land, cyan);
+hidden(land);
+
+text(cap, (cx, h*0.9), "a flat 2D map…");
+size(cap, 30*u); color(cap, dim); wrap(cap, w*0.7);
+
+// 1 — the map settles in 2D (Wave Function Collapse).
+step("settle") {
+  par {
+    say(cap, "a flat 2D map, generated cell by cell…");
+    run(world, 16, 3.4);
+  }
+}
+wait(0.4);
+
+// 2 — the same grid lifts into 3D: fade the flat map, reveal the terrain (still
+// near top-down, so it still reads flat — the map has just gained a third axis).
+step("lift") {
+  par {
+    say(cap, "…is secretly a 3D world");
+    fade(world.cells, 0.6);
+    fade(world.lines, 0.6);
+    show(land, 0.7);
+  }
+}
+
+// 3 — pull back and tilt so the WHOLE world is in frame at once.
+step("reveal") {
+  orbit3(25, 38, 27, 3.8, smooth);
+}
+wait(0.4);
+
+// 4 — a slow rotation around the full terrain.
+step("rotate") {
+  seq {
+    say(cap, "one grid — 2D pathfinding AND 3D terrain, bridged by manic");
+    orbit3(170, 34, 27, 5.2, smooth);
+  }
+}
+
+// 5 — then fly in close and low over the peaks. That's manic.
+step("zoom") {
+  orbit3(235, 15, 10, 4.6, smooth);
+}
+wait(1.2);

package/examples/heightmap3.manic

@@ -0,0 +1,23 @@
+// heightmap3 — a Grid Kit → 3D bridge. A 2D grid's per-cell state is lifted into a
+// surface3-style terrain mesh. The grid kit stays entirely 3D-unaware; heightmap3
+// lives on the 3D side and just reads the grid's cells. Here a seeded Wave Function
+// Collapse settles a map, then its walls rise into an island terrain a camera orbits.
+title("Heightmap3 — A Grid Becomes Terrain");
+canvas("16:9");
+template("neon");
+
+// A grid-kit map: `collapse` pre-simulates a seeded WFC settle (clustered walls).
+grid(mz, (cx, cy), 18, 14, 30);
+collapse(mz, "islands", 5);
+hidden(mz.cells); hidden(mz.lines);   // we only want the 3D terrain, not the flat grid
+
+// Lift it: h = 1 for a filled cell, 0 otherwise. The formula raises the walls and
+// blends in organic `fbm` noise for a natural roll — grid value AND noise compose.
+camera3((0, -12, 7), (0, 0, 0.7), 32);
+heightmap3(land, mz, "h*1.5 + fbm(x*1.1, y*1.1)*0.85 + 0.1", 7);
+color(land, cyan);
+
+// A slow turntable so the terrain reads in 3D.
+orbit3(70, 34, 13, 4.5, smooth);
+orbit3(200, 30, 13, 4.5, smooth);
+orbit3(330, 36, 13, 4.5, smooth);