@maniclang/workbench 0.1.11

package/examples/cloud-medusae.manic

@@ -0,0 +1,46 @@
+// cloud-medusae — another @yuruyurau art-tweet in ONE `cloud`: 30,000 points in
+// interleaved layers (`mod(i,5)`, `mod(i,4)`, `mod(i,2)`) swirl into a ring of
+// tailed medusae that pulse over time. A polar plot (radius `q`, angle `c`).
+// Two JS bitwise-isms translated: `**4` → `^4`, and `~(i&1)*80` (bitwise NOT of
+// i&1) → `(1+mod(i,2))*80` — an 80/160 offset per parity. Hue'd + bloomed, 9:16.
+//
+// Original idea by @yuruyurau (https://x.com/yuruyurau). Our own annotated take —
+// pure in (i, t), so it scrubs and records; the p5 original can't.
+//
+//   manic examples/cloud-medusae.manic
+title("A ring of medusae from one formula");
+canvas("9:16");
+template("black");
+
+cloud(medusae, 30000, #ffffff, 0.55) {
+  let s = i/799;
+  let k = 5*cos(i/48);
+  let e = 5*cos(s/9);
+  let d = (hypot(k, e)/(6 + mod(i,4)))^4 + 4;
+  let q = k*(3 + e/2*sin(d*8 + k/9 - t)) - 3*sin(k*d/3) + (1 + mod(i,2))*80;
+  let c = d - t/9 + mod(i,5);
+  let px = q*sin(c);
+  let py = q*cos(c - mod(i,2) + mod(i,5)*3 + 7);
+  let grow = tanh(t*0.5 + 0.12);
+  let x = 540 + px * 1.7 * grow;
+  let y = 960 + py * 1.7 * grow;
+  let hue = mod(mod(i,5)*72 + i*0.01 + t*14, 360);
+}
+
+// ---- textbook annotations ----
+caption(head, "A ring of medusae from one formula", (540, 138), 32);
+caption(sub, "30,000 points, no simulation", (540, 204), 22);
+hidden(head);
+hidden(sub);
+equation(eq, (540, 1706), `p = (q\sin c,\;\; q\cos c')`, 32);
+caption(lab, "a polar plot in interleaved layers (mod i,n)", (540, 1786), 20);
+hidden(eq);
+hidden(lab);
+
+show(head);
+wait(1.4);
+show(sub);
+wait(2.6);
+show(eq);
+show(lab);
+wait(25);

package/examples/cloud-phoenix.manic

@@ -0,0 +1,49 @@
+// cloud-phoenix — another @yuruyurau art-tweet, reimagined in ONE `cloud`. 10,000
+// points flow into a living, wing-like form and morph over time. The original
+// packs a conditional into the amplitude ((y<9?9:5)); manic formulas have no
+// ternary, so it's written with sign():  amp = 7 + 2*sign(9 - s). Coloured per
+// point and bloomed from the centre on a 9:16 Short — every point a pure function
+// of (i, t), so it scrubs and records (the p5 original can't).
+//
+// Original idea by @yuruyurau (https://x.com/yuruyurau) — a prolific poster of
+// these tiny p5.js/dwitter art formulas. This is our own hue'd, annotated take.
+//
+//   manic examples/cloud-phoenix.manic
+title("One formula becomes a phoenix");
+canvas("9:16");
+template("black");
+
+cloud(bird, 10000, #ffffff, 0.72) {
+  let s = i / 353;                          // the reference's "y" parameter
+  let amp = 7 + 2*sign(9 - s);              // (y<9?9:5), written with sign()
+  let k = (amp + cos(s*31 - t)) * cos(i/44);
+  let e = s/9 - 14;
+  let d = hypot(k, e) / 1.6;
+  let c = d - t/2;
+  // raw coords (centred at 0), then bloom + scale onto the 1080x1920 frame
+  let px = (d*9 + k*k)*cos(c);
+  let py = (55 + d*9)*sin(c/3) + 4*sin(k*2) + s/29*k*(e + 3*sin(e*4 - d*4 + t*3));
+  let grow = tanh(t * 0.5 + 0.12);
+  let x = 540 + px * 2.6 * grow;
+  let y = 960 + (py - 120) * 2.6 * grow;   // -120 recentres the form's DC offset
+  let r = 1.4;
+  let hue = mod(s * 13 + t * 16, 360);     // a rainbow flowing along the form
+}
+
+// ---- textbook annotations ----
+caption(head, "One formula becomes a phoenix", (540, 132), 38);
+caption(sub, "10,000 points, no simulation", (540, 200), 24);
+hidden(head);
+hidden(sub);
+equation(eq, (540, 1706), `p_i = f(i,\; t)`, 46);
+caption(lab, "each point placed by its index i and time t", (540, 1786), 22);
+hidden(eq);
+hidden(lab);
+
+show(head);
+wait(1.4);
+show(sub);
+wait(2.6);
+show(eq);
+show(lab);
+wait(27);

package/examples/cloud-plumes.manic

@@ -0,0 +1,47 @@
+// cloud-plumes — another @yuruyurau art-tweet in ONE `cloud`: 30,000 points in
+// two mirrored layers (`mod(i,2)`) drift into flowing frond/plume forms and morph
+// over time. A polar plot — radius `q`, angle `c` — coloured per point and
+// bloomed from the centre on a 9:16 Short. `mag(k,e)^2` becomes `k*k+e*e`, and
+// the canvas `w` (=400) is folded into the constant `i/1200`.
+//
+// Original idea by @yuruyurau (https://x.com/yuruyurau) — a prolific poster of
+// tiny p5.js/dwitter art formulas. Our own hue'd, annotated take. Pure in (i, t),
+// so it scrubs and records; the p5 original can't.
+//
+//   manic examples/cloud-plumes.manic
+title("Two fronds from one formula");
+canvas("9:16");
+template("black");
+
+cloud(fronds, 30000, #ffffff, 0.6) {
+  let m = mod(i, 2) * 3;            // two layers: 0, 3
+  let k = 14*cos(i/39);
+  let e = i/1200 - 13;
+  let d = (k*k + e*e)/59 + 1;
+  let q = 89 - sin(k)*d + k*(8/d + sin(d*3 + e/9 - t));
+  let c = d*0.45 - sin(t - d)/8 - t/8 + m;
+  let px = q*sin(c);
+  let py = (q + 40 + 30*sin(c*2 + m))*cos(c);
+  let grow = tanh(t*0.5 + 0.12);
+  let x = 540 + px * 2.0 * grow;
+  let y = 960 + py * 2.0 * grow;
+  let hue = mod(m*70 + i*0.03 + t*15, 360);
+}
+
+// ---- textbook annotations ----
+caption(head, "Two fronds from one formula", (540, 138), 36);
+caption(sub, "30,000 points, no simulation", (540, 206), 22);
+hidden(head);
+hidden(sub);
+equation(eq, (540, 1706), `p = (q\sin c,\;\; (q{+}\Delta)\cos c)`, 30);
+caption(lab, "a polar plot: radius q, angle c, per point", (540, 1786), 20);
+hidden(eq);
+hidden(lab);
+
+show(head);
+wait(1.4);
+show(sub);
+wait(2.6);
+show(eq);
+show(lab);
+wait(25);

package/examples/cloud-pottery.manic

@@ -0,0 +1,104 @@
+// cloud-pottery — the OpenProcessing weekly "Pottery" creative-coding challenge
+// (https://openprocessing.org/curation/78544) reimagined in ONE manic `cloud`. The p5
+// original stacks random easing curves into pot silhouettes and stipples them with
+// thousands of dots across three graphics layers, plus recursive sticks + flowers.
+// manic can't recurse in a flat `f(i,t)` cloud — so the sticks/flowers/layers are left
+// to the original — but the SIGNATURE look (dotted ellipse-ring vases, each a unique
+// wavy profile, shaded front-bright) is one closed-form formula per point. Pure in
+// (i,t): the pots grow in bottom-up and record exactly, where the p5 sketch draws once.
+//
+//   manic examples/cloud-pottery.manic
+title("Pottery — a p5 sketch, reimagined as one cloud");
+canvas("16:9");
+template("black");
+
+cloud(pots, 40320, #c47a3d, 0.95) {
+  // decode the flat index i into (pot, ring, angle-around-the-ellipse)
+  let per = 5760;                       // 90 rings * 64 dots
+  let pot = floor(i / per);
+  let rem = i - pot * per;
+  let ring = floor(rem / 64);
+  let k = rem - ring * 64;
+  let yl = ring / 89;                   // 0 = base, 1 = rim
+  let a = k / 64 * tau;
+
+  // 7 pots across a 1280-wide frame (margin 86)
+  let span = 1108;
+  let potX = 86 + (pot + 0.5) * (span / 7);
+  let potW = (span / 7) * 0.4;          // half-width
+  let baseY = 545;
+  let potH = potW * (1.0 + 1.8 * rand2(pot, 1.7));
+
+  // a wavy vase silhouette, unique per pot (a couple of seeded sine harmonics)
+  let seed = rand2(pot, 3.7);
+  let prof = 0.55 + 0.28 * sin(yl * pi + seed * tau) + 0.12 * sin(yl * tau + seed * 9.0);
+  let R = potW * prof;
+
+  // ellipse ring, 0.22 vertical squash for perspective, a little per-dot jitter
+  let x = potX + R * sin(a) + 1.4 * rand2(i, 2.1);
+  let y = baseY - yl * potH + R * 0.22 * (-cos(a)) + 1.4 * rand2(i, 5.3);
+
+  // grow bottom-up: only rings below the rising build-line have appeared
+  let build = tanh(t * 0.55) * 1.14;
+  let vis = 1 - smoothstep(build, build + 0.10, yl);
+
+  let r = 0.9 + 1.1 * rand2(i, 7.0);              // fine stipple
+  // terracotta while it grows; AFTER the pots are formed the glaze shifts, cycling
+  // through the "colour sets" the p5 original picks at random — same scene, live.
+  let cyc = (t - 4.0) * step(4.0, t);            // 0 until t=4, then climbs
+  let hue = mod(26 + cyc * 34.0 + 16 * rand2(pot, 4.0), 360);
+  let alpha = (0.38 + 0.55 * (0.5 - 0.5 * cos(a))) * vis;  // near-side brighter; fades in
+}
+
+// flowering sprigs on SOME vessels (the original branches recursively; a flat cloud
+// can't, so this is a hash-selected subset with a curved stem + a dotted flower head)
+cloud(sprigs, 12000, #ffdd88, 0.92) {
+  let per = 2000;
+  let pot = floor(i / per);
+  let rem = i - pot * per;
+  let has = step(0.55, rand2(pot, 9.1));          // ~45% of pots get a sprig
+
+  // recompute the pot geometry so the sprig sits on the rim
+  let span = 1108;
+  let potX = 86 + (pot + 0.5) * (span / 7);
+  let potW = (span / 7) * 0.4;
+  let baseY = 545;
+  let potH = potW * (1.0 + 1.8 * rand2(pot, 1.7));
+  let rimY = baseY - potH;
+  let seedF = rand2(pot, 5.9);
+  let stemLen = potH * (0.8 + 0.7 * seedF);
+  let lean = (rand2(pot, 2.3) - 0.5) * 80;
+
+  let isStem = 1 - step(600, rem);                // first 600 dots = stem, rest = head
+  // stem: a gentle bow from the rim upward
+  let ts = rem / 600;
+  let sx = potX + lean * ts + 10 * sin(ts * pi + seedF * 6.0);
+  let sy = rimY - stemLen * ts;
+  // flower head at the stem top (ts = 1)
+  let hx = potX + lean + 10 * sin(pi + seedF * 6.0);
+  let hy = rimY - stemLen;
+  let tf = (rem - 600) / 1400;
+  let fang = tf * tau * 7.0;                       // spiral fills the head
+  let petal = 0.5 + 0.5 * abs(sin(fang * 2.5));    // 5-lobe petals
+  let frad = (14 + 8 * seedF) * petal * (0.35 + 0.65 * rand2(i, 3.3));
+  let fx = hx + frad * sin(fang) + 3 * (rand2(i, 7.7) - 0.5);
+  let fy = hy + frad * (-cos(fang)) + 3 * (rand2(i, 8.8) - 0.5);
+
+  let x = select(sx, fx, isStem);
+  let y = select(sy, fy, isStem);
+  let r = select(1.0 + 0.5 * rand2(i, 1.1), 1.3 + 1.5 * rand2(i, 2.2), isStem);
+  let hue = select(96, 44, isStem);               // stem green, flower gold
+  let grow = smoothstep(2.6, 4.6, t);             // sprigs sprout after the pots form
+  let alpha = has * grow * (0.4 + 0.55 * rand2(i, 6.6));
+}
+
+// ---- textbook annotations ----
+caption(head, "Pottery — one formula per dot", (640, 60), 30);
+caption(sub, "vases grown bottom-up, sprigged, then re-glazed live — all pure in (i, t)", (640, 112), 20);
+hidden(head);
+hidden(sub);
+
+show(head);
+wait(2.4);
+show(sub);
+wait(11);   // pots grow, sprigs sprout, then the glaze cycles the palette

package/examples/cloud-shells.manic

@@ -0,0 +1,50 @@
+// cloud-shells — a dwitter-style art-tweet reimagined in manic: ONE `cloud` of
+// 10,000 points in three layers (`mod(i,3)`), placed by a polar formula — radius
+// `q`, angle `c` — then coloured per point (a hue gradient per form) and bloomed
+// out of the centre. Rebuilt as a textbook Short: every point a pure function of
+// (i, t), so it scrubs and records.
+//
+// Original idea by @yuruyurau (https://x.com/yuruyurau) — a prolific poster of
+// these tiny p5.js/dwitter art formulas. This is our own hue'd, annotated take.
+//
+//   manic examples/cloud-shells.manic
+title("One formula, ten thousand points");
+canvas("9:16");
+template("black");
+
+cloud(swirl, 10000, #ffffff, 0.72) {
+  let m = mod(i, 3) * 4;                          // three layers: 0, 4, 8
+  let k = 9 * cos(i / 81);
+  let e = i / 461 - 11;
+  let d = hypot(k, e)^4 / 40000 + 1.5 + sin(t/2 + m)/4;
+  let q = 89 - e*sin(k) + k*(4 + 2*sin(d*9 + e/9 - t));
+  let c = d + sin(t - d*4)/9 - t/9 + m;
+  // raw shell coords (centred at 0), then bloom + scale onto the 1080x1920 frame
+  let qx = q*cos(c);
+  let qy = (q + 30)*sin(c);
+  let grow = tanh(t * 0.5 + 0.12);               // blooms from the centre
+  let x = 540 + qx * 2.9 * grow;
+  let y = 980 + qy * 2.9 * grow;
+  let r = 1.4;
+  // colour: a gradient along each form (index) with the three layers offset, all
+  // slowly cycling — every point its own hue
+  let hue = mod(m * 46 + i * 0.05 + t * 18, 360);
+}
+
+// ---- textbook annotations ----
+caption(head, "One formula, 10,000 points", (540, 132), 40);
+caption(sub, "a 200-char art-tweet, rebuilt in manic", (540, 202), 24);
+hidden(head);
+hidden(sub);
+equation(eq, (540, 1706), `p = (q\cos c,\; q\sin c)`, 44);
+caption(lab, "a polar plot: radius q, angle c, per point", (540, 1784), 22);
+hidden(eq);
+hidden(lab);
+
+show(head);
+wait(1.4);
+show(sub);
+wait(2.6);
+show(eq);
+show(lab);
+wait(17);

package/examples/cloud-starfield.manic

@@ -0,0 +1,23 @@
+// cloud-starfield — again the same primitive, now a scatter, not a curve: a
+// drifting starfield built on `noise` and `mod`. Each star sits at a hashed
+// position and rains downward, wrapping at the bottom, with a hashed size — the
+// point being that `cloud` places points by whatever rule you give it. A 9:16
+// Short held 20s so the drift is visible.
+//
+//   manic examples/cloud-starfield.manic
+title("cloud — a drifting starfield");
+canvas("9:16");
+template("black");
+
+cloud(stars, 900, #ffffff, 0.9) {
+  let x = 1080 * noise(i, 1);
+  // fall over time and wrap the height with mod(...) (a 2-arg formula function)
+  let y = mod(1920 * noise(i, 7) + t * 90, 1920);
+  let r = 0.6 + 1.8 * noise(i, 3);
+  // colour reveal: stars start cool blue-white, then drift into gentle
+  // per-star colour as `spread` grows and the whole field slowly cycles
+  let spread = tanh(t * 0.25);
+  let hue = mod(210 + 150 * noise(i, 5) * spread + t * 18, 360);
+}
+
+wait(20);

package/examples/cloud-wave-lattice.manic

@@ -0,0 +1,23 @@
+// cloud-wave-lattice — a 50x50 grid of points unpacked from the 1-D index with
+// floor/mod, rippling as a travelling wave. Same `cloud` primitive, a physics-
+// flavoured field this time: index arithmetic gives you a lattice, and `t` drives
+// the wave. On a 9:16 Short, held 20s so the ripple travels through fully.
+//
+//   manic examples/cloud-wave-lattice.manic
+title("cloud — a rippling 50x50 lattice");
+canvas("9:16");
+template("black");
+
+cloud(sheet, 2500, #7cf05a, 0.95) {
+  let col = mod(i, 50);
+  let row = floor(i / 50);
+  let x = 60 + col * 19.5;
+  let y = 220 + row * 28 + 70 * sin(col * 0.4 + row * 0.2 + t * 2);
+  let r = 3;
+  // colour reveal: starts near green (hue 140), then fans into rainbow bands
+  // running down/across the sheet as `spread` grows and the wheel cycles
+  let spread = tanh(t * 0.3);
+  let hue = mod(140 + (row * 7 + col * 3) * spread + t * 30, 360);
+}
+
+wait(20);

package/examples/cloud-word.manic

@@ -0,0 +1,31 @@
+// cloud-word — type a word, get a particle swarm that flies in from all sides,
+// assembles into the letters, holds, then bursts apart. The `cloud` primitive's
+// `from text("…")` source fills the glyphs and hands each point its home as
+// `hx`/`hy`; the block formulas fly those homes in and out over time `t`. Change
+// the word and it just works — the end-user's creativity, not a hard-coded logo.
+//
+//   manic examples/cloud-word.manic
+title("cloud — a word from a swarm");
+canvas("9:16");
+template("black");
+
+cloud(word, 1800, #ffffff, 0.95) from text("MANIC") {
+  // fly-in start: golden-angle scatter around the canvas centre (540, 960)
+  let din = 500 + mod(i * 97, 520);
+  let sx = 540 + cos(i * 2.39996) * din;
+  let sy = 960 + sin(i * 2.39996) * din;
+  // burst-out end: a different hashed angle
+  let ex = 540 + cos(i * 4.123) * (520 + mod(i * 53, 420));
+  let ey = 960 + sin(i * 4.123) * (520 + mod(i * 53, 420));
+  // timeline: assemble ~t=1.4 (per-dot stagger), hold, burst ~t=7.5
+  let p = t - mod(i * 7, 29) * 0.05;
+  let asm = 0.5 * (1 + tanh((p - 1.4) * 2.0));
+  let bst = 0.5 * (1 + tanh((t - 7.5) * 1.6));
+  let x = sx * (1 - asm) + (hx * (1 - bst) + ex * bst) * asm;
+  let y = sy * (1 - asm) + (hy * (1 - bst) + ey * bst) * asm;
+  let r = 2.4;
+  // a left-to-right rainbow across the word, gently cycling
+  let hue = mod(hx * 0.5 + t * 25, 360);
+}
+
+wait(11);

package/examples/cloud3-ripple.manic

@@ -0,0 +1,53 @@
+// cloud3-ripple — the manic answer to a raymarched Shadertoy. The original
+// (https://www.shadertoy.com/view/tssSDN) ray-marches a grid of boxes whose
+// heights ripple in a wave radiating from a bouncing sphere. Ray-marching (a
+// per-pixel loop over an SDF scene) is out of scope for manic's closed-form
+// fields — but the OUTCOME is pure 3D geometry, so we REIMAGINE it with `cloud3`:
+// a 64×64 grid of points whose height is a travelling wave centred on a moving
+// sphere, each point a closed-form function of its index and time. Real 3D,
+// projected by `camera3`, seekable and recordable — no raymarch, no assets.
+//
+//   manic examples/cloud3-ripple.manic
+title("A rippling grid — the cloud3 answer to a raymarch");
+canvas("16:9");
+template("black");
+
+// manic 3D is Z-up: the grid floor lies in the x-y plane and ripples UP in z.
+camera3((11, -11, 8), (0, 0, 0.4), 40, perspective);
+
+// the grid: each point bobs on a wave that radiates from the sphere's position
+cloud3(grid, 4096, #ff3524, 1.0) {
+  let gx = mod(i, 64) / 63 - 0.5;          // cell column 0..63 → -0.5..0.5
+  let gy = floor(i / 64) / 63 - 0.5;       // cell row
+  let x = gx * 9;                          // world -4.5..4.5 (floor)
+  let y = gy * 9;
+  let sx = sin(t * 1.8) * 2.4;             // the sphere's orbit, inlined
+  let sy = cos(t * 2.2) * 2.4;
+  let d = hypot(x - sx, y - sy);           // in-plane distance to the sphere
+  let fall = 1 - smoothstep(0.0, 3.4, d);  // near the sphere ⇒ bob more
+  let z = 1.35 * sin(rand(i) * 3.14 + t * 2.5 + d * 2.2) * fall; // HEIGHT: per-cell phase + wave
+  let r = 0.09;
+  let hue = mix(2.0, 46.0, clamp(z * 0.7 + 0.4, 0.0, 1.0));      // red troughs → gold crests
+}
+
+// the little sphere that drives the wave (a tiny cloud3 shell, orbiting)
+cloud3(ball, 90, #fff3b0, 1.0) {
+  let phi = i * 2.39996;
+  let ct = 1.0 - 2.0 * (i + 0.5) / 90.0;
+  let st = sqrt(1.0 - ct * ct);
+  let bx = sin(t * 1.8) * 2.4;
+  let by = cos(t * 2.2) * 2.4;
+  let x = bx + 0.42 * st * cos(phi);
+  let y = by + 0.42 * st * sin(phi);
+  let z = 1.7 + 0.42 * ct;
+  let r = 0.06;
+}
+
+caption(head, "One wave, a moving source", (640, 68), 34);
+caption(sub, "a cloud3 grid + a bouncing sphere — real 3D, no raymarch", (640, 126), 22);
+hidden(head);
+hidden(sub);
+show(head);
+wait(1.5);
+show(sub);
+wait(26);

package/examples/cloud3-sphere.manic

@@ -0,0 +1,26 @@
+// cloud3-sphere — the 3D twin of `cloud`: N points placed by closed-form x/y/z
+// formulas of the index `i` and live time `t`, projected by the orbit `camera3`.
+// A golden-angle spiral spreads 2500 points evenly over a sphere; the radius
+// breathes and the whole shell slowly rotates, each point cycling its own hue.
+// Same primitive philosophy as 2D `cloud`, one dimension up.
+//
+//   manic examples/cloud3-sphere.manic
+title("cloud3 — a breathing rainbow sphere");
+canvas(800, 800);
+template("black");
+
+camera3((9, -9, 6), (0, 0, 0), 42, perspective);
+
+cloud3(orb, 2500, #ffffff, 0.95) {
+  let phi = i * 2.39996;                 // golden angle around the axis
+  let ct = 1 - 2 * (i + 0.5) / 2500;     // cos(theta): points spread evenly in z
+  let st = sqrt(1 - ct * ct);            // sin(theta)
+  let rad = 3 + 0.5 * sin(t * 2 + i * 0.02);   // the shell breathes
+  let x = rad * st * cos(phi + t * 0.4); // ...and slowly rotates
+  let y = rad * st * sin(phi + t * 0.4);
+  let z = rad * ct;
+  let r = 0.05;
+  let hue = mod(i * 0.18 + t * 24, 360);
+}
+
+wait(10);

package/examples/clt.manic

@@ -0,0 +1,35 @@
+// ============================================================================
+//  clt.manic  —  the Central Limit Theorem (stats Tier 3, the flagship payoff)
+// ----------------------------------------------------------------------------
+//  `clt(id, (cx,cy), samplesize, trials, [seed], [width], [height])` runs `trials`
+//  experiments — each the average of `samplesize` dice — and histograms those
+//  averages. However flat a single die is, the averages pile into a BELL. Draws
+//  the histogram of sample means (`{id}.bar{k}`, tagged `{id}.bars`), the normal
+//  curve they converge to (`{id}.curve`), the mean line, ticks, and an info
+//  label. Seeded → the render is identical every time.
+//
+//  TO ADAPT: change `samplesize` (bigger n → tighter bell) or `trials` (more →
+//  smoother). `seed` picks the reproducible random sequence.
+// ============================================================================
+
+title("The Central Limit Theorem");
+canvas("16:9");
+
+clt(ct, (cx, cy + 20), 5, 1200, 7, 660, 300);
+untraced(ct.bars);      // the sample means pile up, bar by bar
+untraced(ct.curve);     // the normal curve draws in last
+hidden(ct.mean);
+
+text(cap, (cx, h - 46), ""); size(cap, 22); color(cap, dim); display(cap);
+
+say(cap, "one die is flat — 1 to 6 are equally likely. but average FIVE dice…", 0.5);
+stagger(0.03) { for k in 0..30 { draw(ct.bar{k}, 0.3); } }
+wait(1.0);
+
+say(cap, "…and repeat 1200 times: the averages pile up around the middle", 0.5);
+show(ct.mean, 0.4);
+wait(1.6);
+
+say(cap, "they trace a bell — the Central Limit Theorem: averages are normal", 0.5);
+draw(ct.curve, 1.1);
+wait(2.0);

package/examples/collide-blocks-annotated.manic

@@ -0,0 +1,45 @@
+// ============================================================================
+//  collide-blocks-annotated.manic  —  conservation of momentum, the MANIC way
+// ----------------------------------------------------------------------------
+//  Not a 1:1 port of the lab sim — a guided lesson that ELEVATES it: the live Σp
+//  readout, the KE↔spring-PE energy view, staged callouts, and honest narration
+//  (with a wall-spring, Σp is conserved AT each collision — Newton's 3rd law — not
+//  constant, since the spring is an external force). All base manic over the sim.
+// ============================================================================
+
+title("Conservation of Momentum");
+canvas("16:9");
+
+// the sim's Σp readout sits at the very top (y≈46) — the star of the scene
+collideblocks(cb, (cx, 460), 3, 1, 1);
+hidden(cb);                                   // the bare id hides every part + the readout + energy view
+energygraph(cb, (1055, 250), 84);             // KE ↔ spring PE (tagged cb, revealed by show(cb))
+
+text(hdr, (cx, 104), "Conservation of Momentum"); size(hdr, 30); color(hdr, cyan); bold(hdr); display(hdr); hidden(hdr);
+text(sub, (cx, 140), "block 1 on a spring · block 2 slides in · watch Σp through the collision"); size(sub, 17); color(sub, dim); display(sub); hidden(sub);
+
+// callouts
+text(csp, (360, 330), "spring holds block 1 to the wall"); size(csp, 16); color(csp, lime); display(csp); hidden(csp);
+arrow(asp, (392, 344), (418, 424)); color(asp, dim); stroke(asp, 2); hidden(asp);
+text(cb1, (470, 300), "block 1 · m₁ = 3 kg"); size(cb1, 16); color(cb1, cyan); display(cb1); hidden(cb1);
+text(cb2, (800, 300), "block 2 · m₂ = 1 kg →"); size(cb2, 16); color(cb2, magenta); display(cb2); hidden(cb2);
+
+text(cap, (cx, h - 38), ""); size(cap, 19); color(cap, fg); display(cap);
+
+// ============================== SCRIPT ==============================
+show(hdr, 0.5); show(sub, 0.4);
+wait(0.3);
+show(cb, 0.6);                                 // sim + Σp readout + energy view
+show(csp, 0.3); draw(asp, 0.3); show(cb1, 0.3); show(cb2, 0.3);
+wait(0.4);
+
+say(cap, "block 2 slides toward block 1, which is held by its spring", 0.4);
+wait(0.5);
+say(cap, "they collide — each pushes the other equal and opposite (Newton's 3rd law)", 0.4);
+flash(cb.mom, gold);
+wait(0.5);
+say(cap, "so Σp doesn't jump at the hit — the spring only shifts it BETWEEN collisions", 0.4);
+wait(0.5);
+say(cap, "energy sloshes between motion and the spring, but the total stays put — elastic", 0.4);
+
+run(cb, 12);

package/examples/collide-blocks.manic

@@ -0,0 +1,11 @@
+// collide-blocks.manic — the classic momentum demo. Block 1 (left) is attached to
+// the wall by a SPRING; block 2 slides in freely and they collide with restitution
+// e (1 = elastic → energy conserved; <1 → lost). The live Σp readout (top) shows
+// momentum is conserved at every collision. Built on the shared `collide_1d`.
+title("Colliding blocks — momentum is conserved");
+canvas("16:9");
+text(hdr, (cx, 96), "Block 1 on a spring, block 2 sliding in — watch the momentum readout"); size(hdr, 21); color(hdr, cyan); bold(hdr); display(hdr);
+collideblocks(cb, (cx, 440), 3, 1, 1);
+energygraph(cb, (1040, 210), 90);
+text(cap, (cx, h - 36), "elastic (e=1): total energy (KE + spring PE) is conserved; Σp is conserved at each collision"); size(cap, 15); color(cap, dim); display(cap);
+run(cb, 10);

package/examples/compare-pendulum.manic

@@ -0,0 +1,11 @@
+// compare-pendulum.manic — sensitive dependence: two pendulums 0.001 rad apart.
+//   comparependulum(id,[center],[angle0deg],[unit]) — identical driven-damped
+//   physics, a hair-different start — yet they diverge completely (the butterfly effect).
+title("Two pendulums, one hair apart");
+canvas("16:9");
+text(hdr,(cx,44),"Sensitive dependence — a 0.001 rad difference explodes"); size(hdr,23); color(hdr,cyan); bold(hdr); display(hdr);
+comparependulum(cm, (380,230), 12, 120);
+phase(cm, (900,190), 95);           // θ_A vs θ_B — starts on the diagonal, then scatters
+timegraph(cm, (900,470), 95);       // θ_A(t) & θ_B(t) diverge
+text(cap,(cx,h-32),"cyan and magenta start together, then go their separate ways"); size(cap,16); color(cap,dim); display(cap);
+run(cm, 13);