@maniclang/workbench 0.1.11

package/examples/ai-story.manic

@@ -0,0 +1,118 @@
+title("The Equal-Area Point Inside a Triangle");
+canvas("16:9");
+
+let unit = 80;
+let ox = cx - 3*unit;
+let oy = h*0.80;
+let px = cx;
+let py = oy - 4*unit;
+let qx = ox + 6*unit;
+let qy = oy;
+let rx = (ox + px + qx)/3;
+let ry = (oy + py + qy)/3;
+
+// --- cast (constructors): declare entities at t = 0 ---
+text(head, (cx, h*0.07), "The Equal-Area Point Inside a Triangle");
+display(head); size(head, 40); color(head, gold); hidden(head);
+
+text(prob1, (cx, h*0.13), "Let $O(0,0)$, $P(3,4)$, $Q(6,0)$ be the vertices of triangle $OPQ$.");
+display(prob1); size(prob1, 26); color(prob1, fg); hidden(prob1);
+
+text(prob2, (cx, h*0.185), "Point $R$ inside satisfies $[OPR]=[PQR]=[OQR]$. Find the coordinates of $R$.");
+display(prob2); size(prob2, 26); color(prob2, fg); hidden(prob2);
+
+text(cap, (cx, h*0.93), "");
+display(cap); size(cap, 26); color(cap, cyan); hidden(cap);
+
+point(O, (ox, oy), "O(0,0)");
+hidden(O); hidden(O.label); size(O.label, 26); color(O.label, fg);
+
+point(P, (px, py), "P(3,4)");
+hidden(P); hidden(P.label); size(P.label, 26); color(P.label, fg);
+
+point(Q, (qx, qy), "Q(6,0)");
+hidden(Q); hidden(Q.label); size(Q.label, 26); color(Q.label, fg);
+
+segment(OP, O, P); untraced(OP); color(OP, fg); stroke(OP, 3);
+segment(PQ, P, Q); untraced(PQ); color(PQ, fg); stroke(PQ, 3);
+segment(QO, Q, O); untraced(QO); color(QO, fg); stroke(QO, 3);
+
+centroid(R, O, P, Q);
+label(R, "R(3, 4/3)");
+hidden(R); hidden(R.label); size(R.label, 26); color(R.label, gold);
+
+segment(RO, R, O); untraced(RO); color(RO, gold); stroke(RO, 2.5);
+segment(RP, R, P); untraced(RP); color(RP, gold); stroke(RP, 2.5);
+segment(RQ, R, Q); untraced(RQ); color(RQ, gold); stroke(RQ, 2.5);
+
+polygon(regOPR, (ox, oy), (px, py), (rx, ry), cyan);
+filled(regOPR); opacity(regOPR, 0.30); hidden(regOPR);
+
+polygon(regPQR, (px, py), (qx, qy), (rx, ry), magenta);
+filled(regPQR); opacity(regPQR, 0.30); hidden(regPQR);
+
+polygon(regOQR, (ox, oy), (qx, qy), (rx, ry), lime);
+filled(regOQR); opacity(regOQR, 0.30); hidden(regOQR);
+
+equation(eqCond, (cx, h*0.855), `[OPQ]=12 \quad\Rightarrow\quad [OPR]=[PQR]=[OQR]=4`, 26);
+hidden(eqCond);
+
+equation(eqAns, (cx, h*0.855), `R=\left(3,\ \tfrac{4}{3}\right)`, 34);
+hidden(eqAns);
+
+// --- script (timeline): verbs play in order ---
+show(head, 0.6);
+show(prob1, 0.5);
+show(prob2, 0.5);
+show(cap, 0.3);
+say(cap, "Three vertices, one triangle. We need the point that splits it into three equal areas.");
+wait(1.0);
+
+section("Setting up the triangle");
+par {
+  show(O, 0.4); show(O.label, 0.4);
+  show(P, 0.4); show(P.label, 0.4);
+  show(Q, 0.4); show(Q.label, 0.4);
+}
+say(cap, "Place O, P, and Q on the plane.");
+wait(0.6);
+
+draw(OP, 0.5);
+draw(PQ, 0.5);
+draw(QO, 0.5);
+say(cap, "Connect them to form triangle OPQ.");
+wait(0.8);
+
+section("Finding the equal-area point");
+say(cap, "For R to split it into three EQUAL-area triangles, R must be the centroid.");
+wait(1.2);
+
+par { show(R, 0.5); show(R.label, 0.5); }
+say(cap, "The centroid averages the three vertices.");
+wait(0.6);
+
+par {
+  draw(RO, 0.6);
+  draw(RP, 0.6);
+  draw(RQ, 0.6);
+}
+say(cap, "Draw the three cevians from R to each vertex.");
+wait(0.8);
+
+par {
+  show(regOPR, 0.5);
+  show(regPQR, 0.5);
+  show(regOQR, 0.5);
+}
+say(cap, "Each of the three regions has exactly the same area.");
+wait(1.0);
+
+show(eqCond, 0.6);
+say(cap, "Total area 12, split evenly into three fours.");
+wait(1.5);
+
+fade(eqCond, 0.4);
+show(eqAns, 0.6);
+flash(R, gold);
+say(cap, "So R is the centroid: R = (3, 4/3).");
+wait(2.0);

package/examples/analysis.manic

@@ -0,0 +1,53 @@
+title("Reading a curve: slope, tangent, normal, area");
+canvas("16:9");
+
+text(hdr, (cx, 58), "Asking a curve questions");
+size(hdr, 30); color(hdr, cyan); bold(hdr); display(hdr); hidden(hdr);
+
+// one curve — everything below asks IT, by name
+plot(f, (cx - 440, cy + 30), 140, 110, "sin(x)", (0, 6.3));
+color(f, cyan); stroke(f, 3); untraced(f);
+
+// the area under it — starts collapsed at x=0.6, sweeps open
+area(reg, f, 0.6, 0.6);
+color(reg, lime);
+
+// a live integral readout that climbs as the area sweeps
+integral(area_val, f, 0.6, 0.6, (cx + 340, cy - 210));
+color(area_val, lime);
+
+// tangent + its live slope number, both riding the same point
+tangent(tan, f, 0.6, 240);
+color(tan, gold);
+
+slope(sl, f, 0.6);
+color(sl, gold);
+
+// the normal, perpendicular at the same place
+normal(nrm, f, 0.6, 150);
+color(nrm, magenta); hidden(nrm);
+
+// ---- timeline ----
+show(hdr, 0.5);
+draw(f, 1.4);
+show(tan, 0.5);
+show(sl, 0.4);
+wait(0.4);
+
+// sweep the area open while the tangent + slope slide together and the
+// integral readout climbs
+par {
+  to(reg, x, 5.7, 4);
+  to(area_val, x, 5.7, 4);
+  to(tan, x, 5.7, 4);
+  to(sl, x, 5.7, 4);
+}
+wait(0.4);
+
+// reveal the normal and glide everything back to the first peak (slope 0)
+show(nrm, 0.4);
+par {
+  to(tan, x, 1.571, 2.5);
+  to(sl, x, 1.571, 2.5);
+  to(nrm, x, 1.571, 2.5);
+}

package/examples/archimedes_pi.manic

@@ -0,0 +1,89 @@
+// Approximating pi — Archimedes' method (c. 250 BC): inscribe a regular polygon
+// in a circle and its perimeter closes in on the circumference. For an n-gon in
+// a circle of radius R the perimeter is 2R * n*sin(pi/n), so pi ~ n*sin(pi/n),
+// which -> pi as n grows. We sweep n = 6, 24, 96 (Archimedes' own 96-gon) and
+// zoom in to see the last polygon nearly kiss the circle.
+//
+// Uses: a `for` loop per polygon, computed estimates, a live counter, and the
+// camera (cam + zoom).
+//
+//   manic examples/archimedes_pi.manic
+//   manic examples/archimedes_pi.manic --record out --fps 60
+
+title("Approximating pi");
+canvas("16:9");
+
+let ox = 440;   let oy = 400;   let R = 240;   // circle centre + radius
+
+// the estimates, computed in-language
+let e6  = 6  * sin(pi/6);       // 3.000
+let e24 = 24 * sin(pi/24);      // 3.133
+let e96 = 96 * sin(pi/96);      // 3.141
+
+text(head, (640, 78), "Archimedes: straight lines closing in on a circle");
+display(head);  color(head, cyan);  size(head, 25);  hidden(head);
+text(cap, (640, 675), "");  color(cap, dim);  size(cap, 22);
+
+// the true circle (the target)
+circle(circ, (ox, oy), R);  outlined(circ);  outline(circ, dim);  stroke(circ, 2);  untraced(circ);
+
+// live pi readout
+counter(est, (990, 330), 0, 3, "pi ~ ", "");  display(est);  color(est, lime);  size(est, 40);  hidden(est);
+text(truth, (990, 395), "true pi = 3.14159...");  color(truth, dim);  size(truth, 20);  hidden(truth);
+
+// --- hexagon: n = 6 (magenta) ---
+let n = 6;
+for i in 0..n {
+  let a0 = tau*i/n;   let a1 = tau*(i+1)/n;
+  line(h{i}, (ox + R*cos(a0), oy + R*sin(a0)), (ox + R*cos(a1), oy + R*sin(a1)));
+  color(h{i}, magenta);  stroke(h{i}, 3);  untraced(h{i});  tag(h{i}, p6);
+}
+// --- 24-gon (cyan) ---
+let n = 24;
+for i in 0..n {
+  let a0 = tau*i/n;   let a1 = tau*(i+1)/n;
+  line(g{i}, (ox + R*cos(a0), oy + R*sin(a0)), (ox + R*cos(a1), oy + R*sin(a1)));
+  color(g{i}, cyan);  stroke(g{i}, 3);  untraced(g{i});  tag(g{i}, p24);
+}
+// --- 96-gon (lime), Archimedes' own ---
+let n = 96;
+for i in 0..n {
+  let a0 = tau*i/n;   let a1 = tau*(i+1)/n;
+  line(k{i}, (ox + R*cos(a0), oy + R*sin(a0)), (ox + R*cos(a1), oy + R*sin(a1)));
+  color(k{i}, lime);  stroke(k{i}, 2);  untraced(k{i});  tag(k{i}, p96);
+}
+
+// --- script ---
+show(head, 0.5);
+say(cap, "how close can straight lines get to a curve?");
+draw(circ, 1.0);
+par { show(est, 0.3);  show(truth, 0.3); }
+wait(0.4);
+
+section("6 sides");
+say(cap, "start with a hexagon inside the circle");
+draw(p6, 0.8);
+to(est, value, e6, 1.0);
+wait(0.7);
+fade(p6, 0.4);
+
+section("24 sides");
+say(cap, "more sides hug the circle more tightly");
+draw(p24, 1.0);
+to(est, value, e24, 1.0);
+wait(0.7);
+fade(p24, 0.4);
+
+section("96 sides");
+say(cap, "Archimedes went to 96 sides -- around 250 BC");
+draw(p96, 1.2);
+to(est, value, e96, 1.0);
+pulse(est);
+wait(0.7);
+
+section("Almost a circle");
+say(cap, "zoom in: the polygon edge and the arc nearly touch");
+par { cam((ox, oy - R), 1.5, smooth);  zoom(5, 1.5, smooth); }
+wait(1.4);
+par { cam((cx, cy), 1.0, smooth);  zoom(1, 1.0, smooth); }
+wait(0.8);

package/examples/area_under_curve.manic

@@ -0,0 +1,131 @@
+// Area Under a Curve — a Riemann sum sweeping n = 5, 10, 20, 40 to show the
+// rectangles converging to the exact integral of x^2 on [0, 2.5] = 125/24.
+//
+// This is the FIRST example to use manic's loop layer: `let` variables,
+// arithmetic in arguments, a `for` range loop, and id interpolation (`s5{i}`).
+// The four bar-sets differ only in n / prefix / colour — a future `def` macro
+// would collapse them to one call; loops already do the per-bar work.
+//
+//   manic examples/area_under_curve.manic
+//   manic examples/area_under_curve.manic --record out --fps 60
+
+title("Area Under a Curve");
+canvas(1280, 720);
+
+// --- parameters (edit freely) ---
+let ox = 360;   let oy = 590;     // origin, in screen px
+let ux = 200;   let uy = 52;      // px per unit on each axis
+let a = 0;      let b = 2.5;      // integrate x^2 over [a, b]
+
+text(head, (640, 96), "a Riemann sum becomes an integral");
+display(head);  color(head, cyan);  size(head, 26);  hidden(head);
+text(cap, (640, 656), "");  color(cap, dim);  size(cap, 24);
+
+// axes
+arrow(xax, (ox - 40, oy), (920, oy));   color(xax, dim);  untraced(xax);
+arrow(yax, (ox, oy + 20), (ox, 250));   color(yax, dim);  untraced(yax);
+text(t1, (ox + 1*ux, oy + 24), "1");     color(t1, dim);  size(t1, 18);
+text(t2, (ox + 2*ux, oy + 24), "2");     color(t2, dim);  size(t2, 18);
+text(tb, (ox + b*ux, oy + 24), "2.5");   color(tb, dim);  size(tb, 18);
+
+// the curve y = x^2 over [0, 2.5]
+plot(curve, (ox, oy), ux, uy, "x*x", (a, b));  color(curve, cyan);  z(curve, 3);  untraced(curve);
+text(clab, (ox + b*ux + 30, oy - b*b*uy), "y = x^2");  color(clab, cyan);  size(clab, 22);  hidden(clab);
+
+// --- midpoint rectangles, one loop per count ---
+let n = 5;   let dx = (b - a) / n;
+for i in 0..n {
+  let mid = a + (i + 0.5) * dx;   let h = mid * mid;
+  rect(s5{i}, (ox + mid*ux, oy - h*uy/2), dx*ux, h*uy);
+  filled(s5{i});  color(s5{i}, magenta);  opacity(s5{i}, 0.4);  tag(s5{i}, r5);
+}
+let n = 10;  let dx = (b - a) / n;
+for i in 0..n {
+  let mid = a + (i + 0.5) * dx;   let h = mid * mid;
+  rect(s10{i}, (ox + mid*ux, oy - h*uy/2), dx*ux, h*uy);
+  filled(s10{i});  color(s10{i}, magenta);  opacity(s10{i}, 0.4);  tag(s10{i}, r10);
+}
+let n = 20;  let dx = (b - a) / n;
+for i in 0..n {
+  let mid = a + (i + 0.5) * dx;   let h = mid * mid;
+  rect(s20{i}, (ox + mid*ux, oy - h*uy/2), dx*ux, h*uy);
+  filled(s20{i});  color(s20{i}, magenta);  opacity(s20{i}, 0.4);  tag(s20{i}, r20);
+}
+let n = 40;  let dx = (b - a) / n;
+for i in 0..n {
+  let mid = a + (i + 0.5) * dx;   let h = mid * mid;
+  rect(s40{i}, (ox + mid*ux, oy - h*uy/2), dx*ux, h*uy);
+  filled(s40{i});  color(s40{i}, magenta);  opacity(s40{i}, 0.4);  tag(s40{i}, r40);
+}
+hidden(r5);  hidden(r10);  hidden(r20);  hidden(r40);
+
+// --- script ---
+show(head, 0.5);
+say(cap, "the shaded area under y = x^2 from 0 to 2.5");
+par { draw(xax, 0.5);  draw(yax, 0.5); }
+draw(curve, 0.9);
+show(clab, 0.3);
+wait(0.4);
+
+section("Rectangles");
+say(cap, "n = 5 rectangles  ->  area ~ 5.16");
+show(r5, 0.6);
+wait(0.7);
+fade(r5, 0.3);
+
+say(cap, "n = 10  ->  area ~ 5.20");
+show(r10, 0.5);
+wait(0.6);
+fade(r10, 0.3);
+
+say(cap, "n = 20  ->  area ~ 5.20");
+show(r20, 0.5);
+wait(0.6);
+fade(r20, 0.3);
+
+say(cap, "n = 40  ->  area ~ 5.21 (hugging the curve)");
+show(r40, 0.5);
+wait(0.8);
+
+section("The integral");
+say(cap, "as n grows without bound, the sum IS the integral");
+fade(r40, 0.4);
+text(ans, (640, 300), "exact area = 125/24 = 5.208");  display(ans);  color(ans, lime);  size(ans, 30);  hidden(ans);
+show(ans, 0.5);
+pulse(ans);
+wait(1.6);
+
+// BEGIN WORKBENCH CANVAS
+// Scene built visually. Every line is ordinary Manic — edit freely.
+template("black");
+
+text(idea, (351, 89), "Start with an idea");
+size(idea, 52);
+color(idea, fg);
+hidden(idea);
+
+circle(focus, (509, 397), 118);
+color(focus, cyan);
+hidden(focus, center);
+
+text(note, (362, 605), "Add, arrange, then animate.");
+size(note, 26);
+color(note, dim);
+hidden(note);
+
+rect(rect, (197, 285), 240, 140);
+color(rect, magenta);
+
+step("Reveal") {
+  stagger(0.2) {
+    show(idea, 0.6);
+    show(focus, 0.7, overshoot);
+    show(note, 0.5);
+  }
+}
+
+step("Focus") {
+  pulse(focus, 0.9);
+  flash(idea, gold, 0.9);
+}
+// END WORKBENCH CANVAS

package/examples/art-rakkan.manic

@@ -0,0 +1,69 @@
+// art-rakkan — E.C.H (Eiichi Ishii)'s "dailycoding 20260803" reimagined as ONE
+// per-pixel `shader`. The p5 original scatters ~100 lens/eye modules (parallel
+// bowed béziers inside a rounded shape, some with a soft-shadow glow) across a
+// white field and stamps a red rakkan (落款, artist's seal) in the corner. manic
+// can't draw béziers per pixel — but the LOOK is an SDF field: each module is a
+// `sdvesica` lens filled with bowed stripe-veins, scattered by a per-cell hash,
+// a few carrying a `gaussian` glow; the seal is a `sdroundbox` with white marks.
+// Pure in (u,v,t) — the whole plate scrubs and records; a slow breath keeps it live.
+//
+//   manic examples/art-rakkan.manic
+title("Rakkan — E.C.H generative art, reimagined per-pixel");
+canvas("1:1");
+template("black");
+
+shader(art) {
+  // --- paper ground (warm off-white with a fine tooth) ---
+  let grain = rand2(floor(u * 540.0), floor(v * 540.0));
+  let paper = 0.95 - 0.035 * grain;
+
+  // --- scattered lens modules: tile into cells, hash each cell ---
+  let C = 0.135;                      // cell size
+  let gx = floor(u / C);
+  let gy = floor(v / C);
+  let present = step(0.42, rand2(gx, gy));           // ~58% of cells carry a module
+  let lu = fract(u / C) - 0.5;                        // local coord in the cell
+  let lv = fract(v / C) - 0.5;
+  let jx = (rand2(gx + 3.3, gy) - 0.5) * 0.34;        // jitter the centre
+  let jy = (rand2(gx, gy + 4.7) - 0.5) * 0.34;
+  let ex = lu - jx;
+  let ey = lv - jy;
+  let flip = step(0.5, rand2(gx + 9.1, gy + 2.2));    // 90° orientation
+  let ax = mix(ex, ey, flip);
+  let ay = mix(ey, ex, flip);
+  let sz = 0.30 + 0.12 * rand2(gx + 6.0, gy + 6.0);   // half-size (fits the cell)
+
+  // the lens (vesica) + bowed parallel veins inside it
+  let d = sdvesica(ax / sz, ay / sz, 1.0, 0.62);
+  let inside = step(d, 0.0);
+  let nv = 4.0 + floor(4.0 * rand2(gx + 1.1, gy + 1.1));   // 4..7 veins
+  let bow = ay / sz + 0.32 * (ax / sz) * (ax / sz);        // bow toward centre
+  let stripe = abs(fract(bow * nv) - 0.5);
+  let veins = inside * smoothstep(0.14, 0.05, stripe);
+  let outline = smoothstep(0.04, 0.0, abs(d));
+  let ink = present * clamp(outline + veins, 0.0, 1.0);
+
+  // --- soft glow dot on a few modules (the p5 shadow-blur ellipse) ---
+  let glowon = present * step(0.82, rand2(gx + 13.0, gy + 11.0));
+  let pulse = 0.7 + 0.3 * sin(t * 0.8 + gx + gy);
+  let glow = glowon * gaussian(hypot(lu, lv), 0.15) * 0.6 * pulse;  // tight round soft dot
+
+  // --- compose the greyscale field: paper, dark ink, soft glow ---
+  let field = clamp(mix(paper, 0.07, ink) + glow, 0.0, 1.0);
+
+  // --- red rakkan seal, bottom-left (rounded stone + white seal-script marks) ---
+  let sx = u - 0.135;
+  let sy = v - 0.85;
+  let body = step(sdroundbox(sx, sy, 0.05, 0.08, 0.014), 0.0);
+  let inner = step(sdroundbox(sx, sy, 0.035, 0.065, 0.006), 0.0);   // inset mark area (stone border)
+  let vb = step(0.28, abs(fract(sx * 42.0) - 0.5));                 // vertical seal strokes
+  let hb = step(0.30, abs(fract(sy * 30.0) - 0.5));                 // broken into a seal-script lattice
+  let marks = inner * vb * hb;
+
+  // red = #e2041b ≈ (0.886, 0.016, 0.106); marks paint the paper-white back in
+  let r = mix(field, mix(0.886, paper, marks), body);
+  let g = mix(field, mix(0.016, paper, marks), body);
+  let b = mix(field, mix(0.106, paper, marks), body);
+}
+
+wait(12);

package/examples/aspheric-lens.manic

@@ -0,0 +1,32 @@
+// ============================================================================
+//  aspheric-lens.manic  —  how an asphere kills spherical aberration
+// ----------------------------------------------------------------------------
+//  A prescription surface has a CONIC constant. A plain spherical lens can't
+//  focus a wide beam to a point — the edges bend too much (spherical aberration,
+//  a blur). Reshape that surface into the right ellipse/hyperbola (a conic ≠ 0)
+//  and every ray meets at ONE point. Two real ray-traced lenses, side by side:
+//  same shape, one spherical, one aspheric.
+// ============================================================================
+
+title("Aspheric Correction");
+canvas("16:9");
+
+spotdiagram(sph, (360, 380), "plano-convex");   // spherical surface  → a blur
+spotdiagram(asp, (912, 380), "aspheric");        // conic surface (K≈−0.55) → a point
+
+text(cap, (cx, h - 46), ""); color(cap, fg); size(cap, 24); bold(cap); display(cap); sticky(cap);
+
+// ================= THE SCENE =================
+say(cap, "same lens shape — where do the rays land at focus?", 0.5);
+wait(0.4);
+
+say(cap, "a SPHERICAL surface can't focus the edges — a blur (RMS 1.5 px)", 0.3);
+draw(sph.dots, 1.6);
+wait(0.6);
+
+say(cap, "reshape it to an ASPHERE (conic surface) — a point (RMS 0.1 px)", 0.3);
+draw(asp.dots, 1.4);
+wait(0.6);
+
+say(cap, "one conic constant in the prescription — spherical aberration, gone", 0.3);
+wait(1.2);

package/examples/astronomical-watch.manic

@@ -0,0 +1,96 @@
+// astronomical-watch — a textbook orrery: a clockwork solar system built from
+// REAL SVG assets (Twemoji, vendored by scripts/fetch-svg-assets.sh). The Sun
+// and eight planets are imported vector art; each planet is swept around the Sun by
+// `turn` about the shared pivot, inner planets faster (Kepler's third law). The
+// starfield is a `cloud` (per-point `alpha` twinkle), and the eight real
+// moon-phase glyphs run along the bottom. The maths is derived on the left.
+//
+//   # assets first (one-time): scripts/fetch-svg-assets.sh
+//   manic examples/astronomical-watch.manic
+title("An orrery — a clockwork solar system");
+canvas(1280, 720);
+template("black");
+
+// ---- starfield (a dense cloud; drifts, twinkles, and has depth) ----
+cloud(stars, 320, #dfeaff, 1) {
+  let x = 1280 * noise(i, 1);
+  let y = mod(720 * noise(i, 5) + t * 8, 720);    // slow drift down + wrap
+  let sz = noise(i, 9);
+  let r = 1.1 + sz * sz * 2.6;                     // 1.1..3.7 — depth, all visible
+  let alpha = 0.62 + 0.34 * sin(t * (1.0 + noise(i, 3)) + i * 7);  // 0.28..0.96
+}
+
+// ---- orbit rings (faint, dashed), centred on the Sun at (830, 300) ----
+circle(r1, (830, 300), 40);  outlined(r1); dashed(r1); color(r1, #2a2a4e);
+circle(r2, (830, 300), 64);  outlined(r2); dashed(r2); color(r2, #2a2a4e);
+circle(r3, (830, 300), 90);  outlined(r3); dashed(r3); color(r3, #2a2a4e);
+circle(r4, (830, 300), 118); outlined(r4); dashed(r4); color(r4, #2a2a4e);
+circle(r5, (830, 300), 152); outlined(r5); dashed(r5); color(r5, #2a2a4e);
+circle(r6, (830, 300), 192); outlined(r6); dashed(r6); color(r6, #2a2a4e);
+circle(r7, (830, 300), 232); outlined(r7); dashed(r7); color(r7, #2a2a4e);
+circle(r8, (830, 300), 270); outlined(r8); dashed(r8); color(r8, #2a2a4e);
+
+// ---- the Sun + all eight planets (real imported SVGs) ----
+svg(sun,     (830, 300),  "asset:svg/emoji/sun.svg",     60);
+svg(mercury, (870, 300),  "asset:svg/emoji/mercury.svg", 15);
+svg(venus,   (894, 300),  "asset:svg/emoji/venus.svg",   22);
+svg(earth,   (920, 300),  "asset:svg/emoji/earth.svg",   26);
+svg(mars,    (948, 300),  "asset:svg/emoji/mars.svg",    19);
+svg(jupiter, (982, 300),  "asset:svg/emoji/jupiter.svg", 40);
+svg(saturn,  (1022, 300), "asset:svg/emoji/saturn.svg",  46);
+svg(uranus,  (1062, 300), "asset:svg/emoji/uranus.svg",  28);
+svg(neptune, (1100, 300), "asset:svg/emoji/neptune.svg", 28);
+
+// ---- the lesson (left column; text/caption CENTRE on their point) ----
+caption(head, "A clockwork solar system", (240, 54), 30);
+caption(sub, "inner planets orbit faster", (240, 98), 20);
+hidden(head);
+hidden(sub);
+equation(eq1, (240, 240), `\vec p = (R\cos\omega t,\; R\sin\omega t)`, 26);
+text(lab1, (240, 292), "swept around the Sun");
+hidden(eq1);
+hidden(lab1);
+equation(eq2, (240, 410), `T^{2} \propto R^{3}`, 34);
+text(lab2, (240, 466), "far = slow (Kepler)");
+hidden(eq2);
+hidden(lab2);
+
+// ---- the Moon's phases: eight real glyphs along the bottom ----
+caption(moonlab, "the Moon's phases", (640, 620), 22);
+svg(p1, (300, 668), "asset:svg/emoji/newmoon.svg",       42);
+svg(p2, (405, 668), "asset:svg/emoji/waxingcrescent.svg",42);
+svg(p3, (510, 668), "asset:svg/emoji/firstquarter.svg",  42);
+svg(p4, (615, 668), "asset:svg/emoji/waxinggibbous.svg", 42);
+svg(p5, (720, 668), "asset:svg/emoji/fullmoon.svg",      42);
+svg(p6, (825, 668), "asset:svg/emoji/waninggibbous.svg", 42);
+svg(p7, (930, 668), "asset:svg/emoji/lastquarter.svg",   42);
+svg(p8, (1035, 668),"asset:svg/emoji/waningcrescent.svg",42);
+hidden(moonlab);
+hidden(p1); hidden(p2); hidden(p3); hidden(p4);
+hidden(p5); hidden(p6); hidden(p7); hidden(p8);
+
+// ---- run it: planets orbit (in parallel), the lesson reveals alongside ----
+par {
+  turn(mercury, (830, 300), 4320, 24, linear);   // 12 revolutions — fastest
+  turn(venus,   (830, 300), 2520, 24, linear);   // 7
+  turn(earth,   (830, 300), 1620, 24, linear);   // 4.5
+  turn(mars,    (830, 300), 1080, 24, linear);   // 3
+  turn(jupiter, (830, 300), 432, 24, linear);    // 1.2
+  turn(saturn,  (830, 300), 252, 24, linear);    // 0.7
+  turn(uranus,  (830, 300), 162, 24, linear);    // 0.45
+  turn(neptune, (830, 300), 108, 24, linear);    // 0.3 — slowest
+  seq {
+    show(head);
+    wait(0.9);
+    show(sub);
+    wait(1.4);
+    show(eq1); show(lab1);
+    wait(2.4);
+    show(eq2); show(lab2);
+    wait(2.2);
+    show(moonlab);
+    show(p1); show(p2); show(p3); show(p4);
+    show(p5); show(p6); show(p7); show(p8);
+    wait(4);
+  }
+}

package/examples/asymptote-randomwalk3-reference.manic

@@ -0,0 +1,58 @@
+// The seven Asymptote randomwalk examples reduce to two reusable models:
+// six world-axis choices, or a local 3D turtle that turns by 90°/60°.
+
+title("Deterministic 3D Random Walks");
+canvas("16:9");
+template("mono");
+
+watermark(mark, (w*0.11,h*0.075), "Made With Manic");
+text(kicker, (cx,h*0.07), "GENERATIVE 3D · RANDOMWALK3");
+text(headline, (cx,h*0.13), "The seed fixes the journey. The model changes its shape.");
+text(caption, (cx,h*0.91), "Axis walk · uniform choices · direction colour · camera-aware depth");
+size(kicker,19); bold(kicker); color(kicker,dim);
+size(headline,32); bold(headline);
+size(caption,20); bold(caption); color(caption,gold);
+
+camera3((12,-15,10),(0,0,0),38,orthographic);
+
+randomwalk3(axisWalk, (0,0,0), 12000, 21,
+  "mode=axis distribution=uniform color=direction shade=depth scale=0.12");
+untraced(axisWalk);
+
+randomwalk3(turtle90, (0,0,0), 9000, 21,
+  "mode=turtle angle=90 distribution=gaussian color=turn shade=depth scale=0.12");
+untraced(turtle90); hidden(turtle90);
+
+randomwalk3(turtle60, (0,0,0), 9000, 21,
+  "mode=turtle angle=60 distribution=uniform color=turn shade=depth scale=0.12");
+untraced(turtle60); hidden(turtle60);
+
+step("six world directions") {
+  par { draw(axisWalk,2.20,smooth); view3(axisWalk,"fit",0.60,smooth,1.20); }
+}
+wait(0.65);
+
+step("the frame can turn with the walker") {
+  par {
+    fade(axisWalk,0.40);
+    show(turtle90,0.05);
+    say(caption,"Turtle frame · Gaussian choices · 90° turns",0.40);
+  }
+  par { draw(turtle90,2.20,smooth); view3(turtle90,"fit",0.60,smooth,1.20); }
+}
+wait(0.65);
+
+step("change one angle") {
+  par {
+    fade(turtle90,0.40);
+    show(turtle60,0.05);
+    say(caption,"Turtle frame · uniform choices · 60° turns",0.40);
+  }
+  par { draw(turtle60,2.20,smooth); view3(turtle60,"fit",0.60,smooth,1.20); }
+}
+wait(0.70);
+
+step("inspect the structure") {
+  orbit3(115,28,13,2.10,smooth);
+}
+wait(1.20);