@maniclang/workbench 0.1.11

package/examples/double-integral3.manic

@@ -0,0 +1,43 @@
+title("The double integral — volume as a limit of finer columns");
+canvas("16:9");
+
+camera3((9, -11, 9), (0, 0, 0.7), 40);
+axes3(world, (0, 0, 0), 3);
+color(world, dim);
+
+text(cap, (cx, h - 54), "coarse columns");
+size(cap, 22); color(cap, cyan); bold(cap); display(cap); hidden(cap);
+
+// the surface, kept faint so the columns beneath it read
+surface3(hill, "1.6*exp(-(x*x + y*y)*0.28)", (-3, 3), (-3, 3), 30);
+color(hill, cyan); opacity(hill, 0.22); untraced(hill);
+
+// the volume under it, at three resolutions — each finer sum hugs the surface
+volume3(v1, hill, 3);
+color(v1, lime); hidden(v1);
+volume3(v2, hill, 7);
+color(v2, lime); hidden(v2);
+volume3(v3, hill, 16);
+color(v3, lime); hidden(v3);
+
+// ---- timeline ----
+show(world, 0.5);
+draw(hill, 1.4);
+wait(0.3);
+
+// 3x3: a crude estimate
+show(cap, 0.4);
+show(v1, 0.7);
+wait(1.2);
+
+// 7x7: closer
+fade(v1, 0.5);
+say(cap, "finer: the sum gets closer");
+show(v2, 0.7);
+wait(1.2);
+
+// 16x16: the columns fill the true volume under the surface
+fade(v2, 0.5);
+say(cap, "finer still -> the true volume (a double integral)");
+show(v3, 0.8);
+orbit3(70, 34, 16, 4.5);

package/examples/double-pendulum.manic

@@ -0,0 +1,35 @@
+// ============================================================================
+//  double-pendulum.manic  —  chaos, on the physics baseline (Layer 1)
+// ----------------------------------------------------------------------------
+//  `doublependulum(id, [center], [angle1], [angle2], [unit])` — two arms hinged
+//  end-to-end: deterministic, yet exquisitely sensitive to initial conditions.
+//  PRE-SIMULATED with RK4 (so the render is frame-identical every run). It's a
+//  4-D system, so it inherits `phase` (θ₁ vs θ₂), `timegraph`, and `energygraph`
+//  — but NOT `well` (there's no single-variable potential). `run(id,[dur])` plays
+//  it; drawing `{id}.path` in parallel traces the outer bob's chaotic curve.
+//
+//  TO ADAPT: nudge angle2 by one degree and re-run — the trail diverges completely.
+// ============================================================================
+
+title("Double pendulum — deterministic chaos");
+canvas("16:9");
+
+text(hdr, (cx, 44), "Double pendulum — deterministic, yet unpredictable");
+size(hdr, 24); color(hdr, cyan); bold(hdr); display(hdr);
+
+// the chaotic sim on the left (outer bob traces the wild curve)
+doublependulum(dp, (400, 250), 125, 110);
+untraced(dp.path);
+
+// the views that DO apply to a 4-D system (no potential well here)
+phase(dp, (900, 190), 100);        // θ₁ vs θ₂ — the coupled angles
+energygraph(dp, (900, 480), 100);  // KE / PE / total (total ~conserved)
+
+text(cap, (cx, h - 32), "outer bob's trail is chaotic; total energy stays (nearly) conserved — no friction");
+size(cap, 16); color(cap, dim); display(cap);
+
+// trace the chaotic trail AS the pendulum swings (draw + run in parallel)
+par {
+  run(dp, 12);
+  draw(dp.path, 12);
+}

package/examples/double-spring.manic

@@ -0,0 +1,9 @@
+// double-spring.manic — two masses coupled by springs: energy sloshes (beating).
+title("Coupled springs — energy sloshes back and forth");
+canvas("16:9");
+text(hdr,(cx,44),"Two coupled masses — push one, and the energy beats between them"); size(hdr,22); color(hdr,cyan); bold(hdr); display(hdr);
+doublespring(dd, (430,300), 85);
+phase(dd, (980,200), 100);       // x1 vs x2 — normal modes are diagonals
+energygraph(dd, (980,470), 100);
+text(cap,(cx,h-32),"block 1 (cyan) starts displaced; watch block 2 (magenta) pick up its swing"); size(cap,15); color(cap,dim); display(cap);
+run(dd, 12);

package/examples/drop-mass.manic

@@ -0,0 +1,25 @@
+// ============================================================================
+//  drop-mass.manic  —  an inelastic collision, on the physics baseline (Layer 1)
+// ----------------------------------------------------------------------------
+//  `dropmass(id, [center], [dropheight], [unit])` — a mass is dropped onto a
+//  block resting on a spring. It free-falls, STICKS (perfectly inelastic), then
+//  the heavier combined mass oscillates about a lower equilibrium. The collision
+//  loses kinetic energy — so `energygraph`'s total STEPS DOWN at impact. Then it
+//  is conserved again. PRE-SIMULATED with RK4; `run(id,[dur])` replays it.
+//
+//  TO ADAPT: raise dropheight for a faster impact and a bigger energy step.
+// ============================================================================
+
+title("Drop mass — an inelastic collision loses energy");
+canvas("16:9");
+
+text(hdr, (cx, 44), "Dropped mass sticks — energy is lost in the inelastic collision");
+size(hdr, 22); color(hdr, cyan); bold(hdr); display(hdr);
+
+dropmass(dm, (440, 150), 1.2);
+energygraph(dm, (960, 330), 120);
+
+text(cap, (cx, h - 32), "watch the gold total energy line step DOWN the instant the magenta mass sticks to the block");
+size(cap, 15); color(cap, dim); display(cap);
+
+run(dm, 7);

package/examples/eigen3.manic

@@ -0,0 +1,34 @@
+// ============================================================================
+//  eigen3.manic  —  eigenvectors of a 3x3 matrix (the 3-D echo of eigen)
+// ----------------------------------------------------------------------------
+//  `eigen3(id, (cx,cy,cz), a,b,c,d,e,f,g,h,i, [color])` draws the real
+//  EIGENVECTORS of the 3x3 [[a,b,c],[d,e,f],[g,h,i]] as invariant lines through
+//  the origin — the directions a vector on them only STRETCHES (by λ), never
+//  turns. A real 3x3 always has at least one real eigenvector; a rotation leaves
+//  two complex eigenvalues, which are noted.
+//
+//  TO ADAPT: change the nine numbers. A symmetric matrix (as here) has three
+//  perpendicular real eigen-axes; a rotation like (0,-1,0, 1,0,0, 0,0,1) shows
+//  one real axis (the axis of rotation) + a "2 complex" note.
+// ============================================================================
+
+title("Eigenvectors of a 3x3 matrix");
+canvas("16:9");
+
+camera3((7, 5.5, 6), (0, 0, 0), 42);
+grid3(floor, (0, 0, 0), 3, 1); color(floor, dim); opacity(floor, 0.35);
+
+// symmetric M = [[1,0,0],[0,3,1],[0,1,3]] — three real eigenvalues: 1, 2, 4
+eigen3(ev, (0, 0, 0), 1, 0, 0, 0, 3, 1, 0, 1, 3);
+
+text(cap, (cx, h - 46), ""); size(cap, 22); color(cap, dim); display(cap);
+
+say(cap, "when the matrix acts, most directions turn — but a few only stretch", 0.5);
+orbit3(52, 24, 10, 4, smooth);
+
+say(cap, "those invariant lines are the eigenvectors; the stretch factor is lambda", 0.5);
+orbit3(122, 34, 10, 4, smooth);
+
+say(cap, "this symmetric 3x3 has three real eigenvalues: 1, 2 and 4", 0.5);
+orbit3(58, 22, 9, 4.5, smooth);
+wait(0.5);

package/examples/equal_cuts.manic

@@ -0,0 +1,44 @@
+// Equal Cuts — a circle sliced into equal pieces, repeatedly doubled:
+// 2 → 4 → 8 equal wedges. Each "cut" is a diameter traced across the circle
+// at an equal angle. (manic has no sector primitive yet, so cuts are lines.)
+//
+//   manic examples/equal_cuts.manic
+//   manic examples/equal_cuts.manic --record out --fps 60
+
+title("Equal Cuts");
+canvas(1280, 720);
+
+// the circle to divide, centred at (640, 400) with radius 240
+circle(pie, (640, 400), 240);  stroke(pie, 3);
+
+// four diameters through the centre at 0, 45, 90, 135 degrees.
+// revealed in stages, they cut the circle into 2, then 4, then 8 equal pieces.
+line(c0, (400, 400), (880, 400));  color(c0, magenta);  stroke(c0, 3);  untraced(c0);   //   0
+line(c1, (640, 160), (640, 640));  color(c1, magenta);  stroke(c1, 3);  untraced(c1);   //  90
+line(c2, (470, 230), (810, 570));  color(c2, lime);     stroke(c2, 3);  untraced(c2);   // 135
+line(c3, (810, 230), (470, 570));  color(c3, lime);     stroke(c3, 3);  untraced(c3);   //  45
+
+text(cap, (640, 690), "");    color(cap, dim);   size(cap, 22);
+text(count, (1040, 170), ""); color(count, cyan); size(count, 34);  bold(count);
+
+// --- cut in half ---
+say(cap, "cut the circle in half");
+draw(c0, 0.6);
+say(count, "2 pieces");
+wait(0.5);
+
+// --- cut again: four equal pieces ---
+say(cap, "cut again at a right angle — four equal pieces");
+draw(c1, 0.6);
+say(count, "4 pieces");
+wait(0.5);
+
+// --- and again: eight equal pieces ---
+say(cap, "and again on both diagonals — eight equal pieces");
+par {
+  draw(c2, 0.6);
+  draw(c3, 0.6);
+}
+say(count, "8 pieces");
+pulse(pie);
+wait(1.2);

package/examples/equation.manic

@@ -0,0 +1,16 @@
+// LaTeX math typesetting via `equation(...)`. Put the LaTeX in BACKTICKS so the
+// backslashes survive. Rendered white-on-transparent and tinted by the entity
+// colour, so `color(...)` and `template(...)` both work.
+title("Equations");
+canvas("16:9");
+
+equation(quad, (cx, 150), `x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}`, 68);
+color(quad, cyan);
+
+equation(sum, (cx, 340), `\sum_{k=1}^{n} k = \frac{n(n+1)}{2}`, 60);
+
+equation(euler, (cx, 500), `e^{i\pi} + 1 = 0`, 64);
+color(euler, gold);
+
+equation(intg, (cx, 640), `\int_0^1 x^2\,dx = \tfrac{1}{3}`, 56);
+color(intg, lime);

package/examples/equilateral.manic

@@ -0,0 +1,57 @@
+// Equilateral Triangle — Euclid, Elements Book I, Proposition 1. Given a segment
+// AB: draw the circle centred at A through B and the circle centred at B through
+// A; where they cross is the apex of an equilateral triangle. Every side then
+// equals AB. It's a fully DYNAMIC construction — drag B at the end and the
+// circles, the intersection, and the triangle all stay correct.
+//
+// New geo builtins: circle2 (circle by centre + a point on it) and circlecircle
+// (the two intersection points of two circles).
+//
+// Note: each compass circle has radius |AB|, so keep A and B close enough that
+// the circles fit the canvas (here |AB| ~ 200 px).
+//
+//   manic examples/equilateral.manic
+
+title("Equilateral Triangle");
+canvas("16:9");
+
+text(head, (cx, 96), "Euclid I.1 -- two circles give an equilateral triangle");
+color(head, cyan);  size(head, 24);  hidden(head);
+
+point(A, (540, 470), "A");
+point(B, (740, 470), "B");
+segment(ab, A, B);   color(ab, fg);   stroke(ab, 3);   untraced(ab);
+
+// the two compass circles (each of radius AB)
+circle2(cA, A, B);   color(cA, dim);   stroke(cA, 1.5);   untraced(cA);
+circle2(cB, B, A);   color(cB, dim);   stroke(cB, 1.5);   untraced(cB);
+
+// where they meet: C0 (below AB) and C1 (above AB) — take the apex above
+circlecircle(C, A, B, B, A);
+hidden(C0);   hidden(C1);
+label(C1, "C", (16, -16));   color(C1.label, lime);
+segment(ac, A, C1);   color(ac, lime);   stroke(ac, 3);   untraced(ac);
+segment(bc, B, C1);   color(bc, lime);   stroke(bc, 3);   untraced(bc);
+
+// --- construct it ---
+show(head, 0.5);
+show(A, 0.3);  show(B, 0.3);
+draw(ab, 0.6);
+
+section("Two circles");
+par { draw(cA, 0.9);  draw(cB, 0.9); }
+show(C1, 0.4);
+
+section("The triangle");
+par { draw(ac, 0.7);  draw(bc, 0.7); }
+par { pulse(ac);  pulse(bc);  pulse(ab); }
+wait(0.6);
+
+// --- drag a vertex: it stays equilateral (circles stay on-canvas) ---
+section("Drag a vertex");
+move(B, (700, 360), 1.6, smooth);
+wait(0.3);
+move(B, (660, 560), 1.6, smooth);
+wait(0.3);
+move(B, (740, 470), 1.2, smooth);
+wait(1.0);

package/examples/euler_line.manic

@@ -0,0 +1,51 @@
+// The Euler Line — in any triangle, the circumcenter O, centroid G, and
+// orthocenter H are collinear (and OG : GH = 1 : 2). Constructions are
+// dynamic: drag C and the three centres stay on one line.
+//
+//   manic examples/euler_line.manic
+//   manic examples/euler_line.manic --record out --fps 60
+
+title("The Euler Line");
+canvas(1280, 720);
+
+text(head, (640, 120), "circumcenter, centroid, orthocenter — collinear");
+display(head);  color(head, cyan);  size(head, 26);  hidden(head);
+text(cap, (640, 668), "");  color(cap, dim);  size(cap, 22);
+
+point(A, (300, 560), "A");
+point(B, (1000, 540), "B");
+point(C, (560, 190), "C");
+hidden(A);  hidden(B);  hidden(C);
+
+segment(ab, A, B);  segment(bc, B, C);  segment(ca, C, A);
+untraced(ab);  untraced(bc);  untraced(ca);
+circumcircle(cc, A, B, C);  untraced(cc);
+
+circumcenter(O, A, B, C);  color(O, magenta);  label(O, "O", (18, -14));  hidden(O);
+centroid(G, A, B, C);      color(G, lime);     label(G, "G", (18, -14));  hidden(G);
+orthocenter(H, A, B, C);   color(H, cyan);     label(H, "H", (-30, -14)); hidden(H);
+segment(euler, O, H);      color(euler, magenta);  stroke(euler, 3);  untraced(euler);
+
+show(head, 0.5);
+say(cap, "any triangle, with its circumcircle");
+par { show(A);  show(B);  show(C); }
+par { draw(ab, 0.5);  draw(bc, 0.5);  draw(ca, 0.5); }
+draw(cc, 0.9);
+wait(0.4);
+
+section("Three centres");
+say(cap, "circumcenter O, centroid G, orthocenter H");
+stagger(0.3) { show(O);  show(G);  show(H); }
+wait(0.4);
+
+section("The Euler line");
+say(cap, "they always lie on a single line");
+draw(euler, 0.9);
+wait(0.6);
+
+section("Drag a vertex");
+say(cap, "move C — O, G, H stay collinear");
+move(C, (770, 220), 1.2, smooth);
+move(C, (420, 250), 1.2, smooth);
+move(C, (560, 190), 1.0, smooth);
+wait(1.0);

package/examples/exponential-shells.manic

@@ -0,0 +1,188 @@
+// engine-test-13 — native 3D reconstruction of the reference.
+//
+// The picture is not a flat disc. It is a large, grainy spherical particle cap
+// meeting a family of exponentially growing particle shells at a shared hot
+// origin. Looking down their common axis makes concentric rings; a full camera
+// orbit reveals the offset spherical shells and returns to the opening frame.
+title("∭ 𝘢(𝘵) ∝ eᴴᵗ");
+canvas(1638, 1482);
+template("black");
+bloom(0.90, 0.22, 52);
+
+// Keep the mathematical title fixed in screen space while the 3-D field turns.
+text(formulaTitle, (819, 70), "∭ 𝘢(𝘵) ∝ eᴴᵗ");
+size(formulaTitle, 44);
+color(formulaTitle, gold);
+bold(formulaTitle);
+display(formulaTitle);
+sticky(formulaTitle);
+z(formulaTitle, 20);
+
+// The camera begins on the cap side of the common tangent. It keeps turning in
+// one direction throughout the 20-second hold, completing 1.5 revolutions.
+// That puts opposite face-on views about 6.67 s apart, matching the reference
+// cadence; four fast turns made the alternating side views read as oscillation.
+// The wider field of view keeps the luminous rim inside the complete orbit.
+camera3((-32, 0, 0), (0, 0, 0), 21.0, perspective);
+
+// --- large spherical cap --------------------------------------------------
+// Several low-opacity random skins give the reference its fine, multicolour
+// grain. Surface-point foreshortening naturally creates the bright rim.
+cloud3(outerRose, 52000, #d78676, 0.095) {
+  let ct = -1 + 1.18 * rand2(i, 10.1);
+  let st = sqrt(1 - ct * ct);
+  let th = tau * rand2(i, 11.9);
+  let rr = 4.66 + 0.075 * (rand2(i, 11.3) - 0.5);
+  let x = rr * ct;
+  let y = rr * st * cos(th);
+  let z = rr * st * sin(th);
+  let alpha = 0.42 + 0.58 * (-ct);
+  let r = 0.042;
+}
+glow(outerRose, 1);
+
+cloud3(outerViolet, 48000, #72589f, 0.072) {
+  let ct = -1 + 1.18 * rand2(i, 22.7);
+  let st = sqrt(1 - ct * ct);
+  let th = tau * rand2(i, 24.3);
+  let rr = 4.69 + 0.09 * (rand2(i, 23.9) - 0.5);
+  let x = rr * ct;
+  let y = rr * st * cos(th);
+  let z = rr * st * sin(th);
+  let alpha = 0.30 + 0.70 * (1 + ct);
+  let r = 0.038;
+}
+glow(outerViolet, 1);
+
+cloud3(outerSilver, 36000, #b8d8ef, 0.072) {
+  let ct = -1 + 1.18 * rand2(i, 36.3);
+  let st = sqrt(1 - ct * ct);
+  let th = tau * rand2(i, 38.7);
+  let rr = 4.72 + 0.055 * (rand2(i, 37.1) - 0.5);
+  let x = rr * ct;
+  let y = rr * st * cos(th);
+  let z = rr * st * sin(th);
+  let alpha = 0.22 + 0.78 * (1 + ct);
+  let r = 0.034;
+}
+glow(outerSilver, 1);
+
+// A sparse warm skin just outside the main boundary produces the thin amber
+// fringe visible around the lavender rim in the reference.
+cloud3(outerAmber, 18000, #d67425, 0.026) {
+  let ct = -1 + 1.18 * rand2(i, 50.3);
+  let st = sqrt(1 - ct * ct);
+  let th = tau * rand2(i, 52.9);
+  let rr = 4.79 + 0.08 * (rand2(i, 51.7) - 0.5);
+  let x = rr * ct;
+  let y = rr * st * cos(th);
+  let z = rr * st * sin(th);
+  let alpha = 0.35 + 0.65 * (-ct);
+  let r = 0.036;
+}
+glow(outerAmber, 1);
+
+// A broad, extremely faint splat layer closes the gaps between the fine
+// grains. Additive accumulation turns it into the milky cosmic illumination
+// visible in the recording without replacing the surface texture.
+cloud3(outerCosmos, 90000, #b99bbd, 0.012) {
+  let ct = -1 + 1.18 * rand2(i, 118.1);
+  let st = sqrt(1 - ct * ct);
+  let th = tau * rand2(i, 121.7);
+  let rr = 4.69 + 0.10 * (rand2(i, 119.9) - 0.5);
+  let x = rr * ct;
+  let y = rr * st * cos(th);
+  let z = rr * st * sin(th);
+  let alpha = 0.32 + 0.68 * (-ct);
+  let r = 0.085;
+}
+glow(outerCosmos, 1);
+
+// --- exponential shell family -------------------------------------------
+// Every sphere is tangent at the origin. The gold family grows inward with
+// centre=(-radius,0,0); pink/violet/cyan grow outward from (+radius,0,0).
+// Exponential radius growth turns the face-on rings into the nested horn seen
+// edge-on. `s` selects one sphere and `j` selects a deterministic surface point;
+// each colour family remains one efficient renderer batch.
+cloud3(shellGold, 33600, #ffad24, 0.080) {
+  let per = 4200;
+  let s = floor(i / per);
+  let j = i - s * per;
+  let sr = 0.080 * exp(0.310 * s);
+  let ct = 1 - 2 * rand2(j, s + 63.1);
+  let st = sqrt(1 - ct * ct);
+  let th = tau * rand2(j, s + 65.7);
+  let rr = sr + 0.012 * (rand2(i, s + 4.2) - 0.5);
+  let x = -sr + rr * ct;
+  let y = rr * st * cos(th);
+  let z = rr * st * sin(th);
+  let r = 0.018 + 0.0012 * s;
+}
+glow(shellGold, 1);
+
+cloud3(shellPink, 9200, #ff79c6, 0.075) {
+  let per = 4600;
+  let s = floor(i / per);
+  let j = i - s * per;
+  let k = s + 8;
+  let sr = 0.105 * exp(0.218 * k);
+  let ct = 1 - 2 * rand2(j, k + 73.1);
+  let st = sqrt(1 - ct * ct);
+  let th = tau * rand2(j, k + 75.7);
+  let rr = sr + 0.012 * (rand2(i, k + 4.2) - 0.5);
+  let x = sr + rr * ct;
+  let y = rr * st * cos(th);
+  let z = rr * st * sin(th);
+  let r = 0.028;
+}
+glow(shellPink, 1);
+
+cloud3(shellViolet, 10000, #c398ff, 0.065) {
+  let per = 5000;
+  let s = floor(i / per);
+  let j = i - s * per;
+  let k = s + 10;
+  let sr = 0.105 * exp(0.218 * k);
+  let ct = 1 - 2 * rand2(j, k + 83.1);
+  let st = sqrt(1 - ct * ct);
+  let th = tau * rand2(j, k + 85.7);
+  let rr = sr + 0.012 * (rand2(i, k + 4.2) - 0.5);
+  let x = sr + rr * ct;
+  let y = rr * st * cos(th);
+  let z = rr * st * sin(th);
+  let r = 0.030;
+}
+glow(shellViolet, 1);
+
+cloud3(shellCyan, 16800, #b9ffff, 0.070) {
+  let per = 5600;
+  let s = floor(i / per);
+  let j = i - s * per;
+  let k = s + 12;
+  let sr = 0.105 * exp(0.218 * k);
+  let ct = 1 - 2 * rand2(j, k + 93.1);
+  let st = sqrt(1 - ct * ct);
+  let th = tau * rand2(j, k + 95.7);
+  let rr = sr + 0.012 * (rand2(i, k + 4.2) - 0.5);
+  let x = sr + rr * ct;
+  let y = rr * st * cos(th);
+  let z = rr * st * sin(th);
+  let r = 0.032;
+}
+glow(shellCyan, 1);
+
+// Dense gold dust at the shared tangent becomes the white-hot crescent when
+// viewed from the side and the tiny luminous bullseye when viewed end-on.
+cloud3(junction, 7600, #ffd45a, 0.14) {
+  let ct = 1 - 2 * rand2(i, 103.1);
+  let st = sqrt(1 - ct * ct);
+  let th = tau * rand2(i, 105.7);
+  let rr = 0.095 * (0.45 + 0.55 * rand2(i, 71.2));
+  let x = 0.02 + rr * ct;
+  let y = rr * st * cos(th);
+  let z = rr * st * sin(th);
+  let r = 0.026;
+}
+glow(junction, 1);
+
+orbit3(720, 0, 32, 20, linear);

package/examples/extrude3.manic

@@ -0,0 +1,37 @@
+// Extrude & CSG — turn 2D shapes into 3D solids. `extrude3` sweeps any 2D
+// fillable shape (or a boolean region) straight up; extruding a union/
+// difference/intersect gives constructive-solid-geometry solids. The 2D
+// source shapes are auto-hidden — they're just the cross-section recipe.
+//
+//   manic examples/extrude3.manic
+//   manic examples/extrude3.manic --record out --fps 60
+
+title("Extrude & CSG");
+canvas(1280, 720);
+template("terminal");
+
+camera3((9, -11, 7), (0, 0, 0.8), 45);
+grid3(floor, (0, 0, 0), 6, 1);
+color(floor, dim);
+axes3(world, (0, 0, 0), 3);
+
+// CSG: a square plate MINUS a circular hole → an extruded plate-with-a-hole
+rect(plate, (0, 0), 3, 3);
+circle(hole, (0, 0), 0.9);
+difference(cut, plate, hole);
+extrude3(block, cut, 1.0, (-3.5, 0, 0.6));
+color(block, cyan);
+
+// arbitrary concave polygon: a union of two rects → an L-beam, extruded
+rect(la, (0, 0), 2.4, 0.8);
+rect(lb, (-0.8, 0.8), 0.8, 2.4);
+union(lshape, la, lb);
+extrude3(ell, lshape, 0.9, (3.5, 0, 0.55));
+color(ell, magenta);
+
+// a plain shape extrudes just as happily (a hexagon via a sector sweep)
+sector(hexface, (0, 0), 1.2, 0, 360);
+extrude3(disc, hexface, 0.5, (0, 3.5, 0.3));
+color(disc, gold);
+
+orbit3(60, 24, 17, 8, smooth);

package/examples/factorial-flowchart.manic

@@ -0,0 +1,69 @@
+title("A Flowchart That Runs — the Factorial Loop");
+canvas("16:9");
+template("paper");
+
+let u = (w+h-abs(w-h))/1440;
+watermark(mark, (w*0.15, h*0.04), "Made With Manic");
+text(kicker, (cx, h*0.06), "DIAGRAMS · FLOWCHART · AUTO-LAID");
+text(headline, (cx, h*0.12), "A flowchart that runs");
+size(kicker, 15*u); color(kicker, dim); bold(kicker);
+size(headline, 26*u); bold(headline); wrap(headline, w*0.86);
+
+// `flowchart(fc)` ranks nodes by their connections, auto-fits, and auto-orients:
+// a shallow flow like this stays top-down on its own. No coordinates, no direction
+// to choose. Node shapes are string kinds.
+flowchart(fc);
+node(start, fc, "terminator", "start");
+node(rd, fc, "io", "read n");
+node(init, fc, "process", "f=1  i=1");
+node(dec, fc, "decision", "i <= n?");
+node(body, fc, "process", "f=f*i  i=i+1");
+node(out, fc, "io", "print f");
+node(fin, fc, "terminator", "end");
+
+connect(e1, start, rd);
+connect(e2, rd, init);
+connect(e3, init, dec);
+connect(e4, dec, body);                          // keep looping
+connect(e5, dec, out);                           // exit
+connect(e6, body, dec, orthogonal, right, right); // loop back up the side
+connect(e7, out, fin);
+
+color(e4, cyan); color(e4.hot, cyan);
+color(e5, lime); color(e5.hot, lime);
+color(e6, gold); color(e6.hot, gold);
+annotate(e4, "yes"); annotate(e5, "no"); annotate(e6, "loop");
+
+// A colour key stands in for narration — the diagram explains itself.
+text(k1, (w*0.34, h*0.93), "— continue"); size(k1, 14*u); color(k1, cyan); bold(k1);
+text(k2, (w*0.50, h*0.93), "— exit");     size(k2, 14*u); color(k2, lime); bold(k2);
+text(k3, (w*0.66, h*0.93), "— loop back"); size(k3, 14*u); color(k3, gold); bold(k3);
+
+request(tok, start, "n = 3");
+hidden(fc.nodes);
+hidden(tok.parts);
+
+step("shape") {
+  stagger(0.07) {
+    show(start, 0.3); show(rd, 0.3); show(init, 0.3); show(dec, 0.3);
+    show(body, 0.3); show(out, 0.3); show(fin, 0.3);
+  }
+}
+wait(0.2);
+
+step("run") {
+  seq {
+    show(tok.parts, 0.2);
+    route(tok, e1, 0.4, smooth); route(tok, e2, 0.4, smooth); route(tok, e3, 0.4, smooth);
+    route(tok, e4, 0.4, smooth); route(tok, e6, 0.5, smooth);
+    route(tok, e4, 0.4, smooth); route(tok, e6, 0.5, smooth);
+    route(tok, e4, 0.4, smooth); route(tok, e6, 0.5, smooth);
+    route(tok, e5, 0.4, smooth); route(tok, e7, 0.4, smooth);
+  }
+}
+wait(0.3);
+
+step("takeaway") {
+  seq { pulse(fin, 0.7); pulse(fin, 0.7); }
+}
+wait(1.0);

package/examples/fibonacci-sphere.manic

@@ -0,0 +1,57 @@
+// fibonacci-sphere — an educational cloud3 lesson: how do you scatter N points
+// *evenly* over a sphere? Naive latitude/longitude clumps at the poles; the fix
+// is the golden angle. This builds the answer live — 2000 points placed by the
+// exact closed-form spiral, projected in 3D, with the derivation typeset beside
+// it in LaTeX. The picture and the maths are the same object, which is the point.
+//
+//   manic examples/fibonacci-sphere.manic
+title("The Fibonacci sphere");
+canvas("16:9");
+template("black");
+
+camera3((10, -10, 6), (0, 0, 0), 40, perspective);
+
+// --- headings (caption centres the row; text() would left-anchor and clip) --
+caption(head, "Even points on a sphere", (640, 52), 38);
+caption(ask, "even heights, then a golden-angle turn each step", (640, 108), 22);
+hidden(head);
+hidden(ask);
+
+// --- the sphere: the Fibonacci spiral, breathing-free so it reads as a lesson
+cloud3(orb, 2000, #ffffff, 0.97) {
+  let ct = 1 - 2 * (i + 0.5) / 2000;   // z_i: cos(theta), evenly spaced in [-1,1]
+  let st = sqrt(1 - ct * ct);          // r_i: ring radius at that height
+  let th = i * 2.39996;                // theta_i: i * the golden angle
+  let x = 3 * st * cos(th + t * 0.25); // (slow spin so it reads as a solid)
+  let y = 3 * st * sin(th + t * 0.25);
+  let z = 3 * ct;
+  let r = 0.05;
+  let hue = mod(200 + i * 0.14, 360);  // a cool→warm gradient down the spiral
+}
+untraced(orb);
+
+// --- the derivation, typeset beside it ------------------------------------
+equation(e1, (270, 300), `z_i = 1 - \dfrac{2i+1}{N}`, 34);
+equation(e2, (270, 410), `r_i = \sqrt{1 - z_i^{2}}`, 34);
+equation(e3, (270, 520), `\theta_i = i\,\varphi`, 34);
+equation(e4, (300, 640), `\varphi = \pi(3-\sqrt5) \approx 137.5^\circ`, 30);
+hidden(e1);
+hidden(e2);
+hidden(e3);
+hidden(e4);
+
+// --- lesson beats ---------------------------------------------------------
+show(head);
+wait(0.8);
+show(ask);
+wait(1.2);
+draw(orb, 3);                 // the sphere grows in as the points appear
+wait(0.6);
+show(e1);                     // even heights
+wait(1.6);
+show(e2);                     // the ring radius at each height
+wait(1.6);
+show(e3);                     // turn a little each step...
+wait(1.4);
+show(e4);                     // ...by the golden angle: the never-repeating turn
+wait(3.5);