@maniclang/workbench 0.1.11

package/examples/lost-in-patterns.manic

@@ -0,0 +1,149 @@
+// lost-in-patterns — a fractal odyssey in four movements, each a different KIND
+// of infinity, each with the RULE that generates it shown on screen (manic's
+// thesis: the diagram is true, so the maths is visible):
+//   I   ∞ by ZOOM       the Mandelbrot set — z→z²+c, a x500 dive into seahorse valley
+//   II  ∞ by PARAMETER  the Julia family — SAME rule, but now c is the knob
+//        (the Mandelbrot set is the MAP of which c give a connected Julia — the
+//         bridge between movements I and II)
+//   III ∞ by ITERATION  a Clifford strange attractor — no shape-formula, one rule fed
+//        its own output 6,000× (cloud … from map)
+//   IV  ∞ by RECURSION  the Koch snowflake — F→F+F--F+F, closing on the paradox:
+//        infinite perimeter, finite area.
+title("Lost in Infinite Patterns");
+canvas("16:9");
+template("black");
+
+// ---------- HUD ----------
+text(head, (cx, 60), "Lost in Infinite Patterns"); display(head); cursor(head); sticky(head);
+text(cap, (cx, h - 42), ""); size(cap, 26); sticky(cap);
+counter(mag, (w - 170, 120), 1, 0, "zoom x", ""); color(mag, gold); hidden(mag);
+
+// a dark card so the teaching panel stays legible over the bright fractals
+polygon(panel, (230, 92), (768, 92), (768, 250), (230, 250), #05070d);
+opacity(panel, 0.5); sticky(panel); hidden(panel);
+
+// the "kind of infinity" chip — one per movement (show/hide, no narration)
+text(kind1, (499, 122), "∞  by ZOOM"); size(kind1, 30); color(kind1, cyan); sticky(kind1); hidden(kind1);
+text(kind2, (499, 122), "∞  by PARAMETER"); size(kind2, 30); color(kind2, magenta); sticky(kind2); hidden(kind2);
+text(kind3, (499, 122), "∞  by ITERATION"); size(kind3, 30); color(kind3, gold); sticky(kind3); hidden(kind3);
+text(kind4, (499, 122), "∞  by RECURSION"); size(kind4, 30); color(kind4, lime); sticky(kind4); hidden(kind4);
+
+// the generating rule of each movement — the maths made visible
+equation(eqIter, (499, 190), `z_{n+1} = z_n^{2} + c`, 34); sticky(eqIter); hidden(eqIter);
+equation(eqC,    (499, 236), `c = 0.7885\,e^{i\theta}`, 26); sticky(eqC); hidden(eqC);
+equation(eqCliff,(499, 196), `\begin{cases} x' = \sin(ay)+c\cos(ax) \\ y' = \sin(bx)+d\cos(by) \end{cases}`, 24); sticky(eqCliff); hidden(eqCliff);
+equation(eqKoch, (499, 188), `F \to F\,{+}\,F\,{-}{-}\,F\,{+}\,F`, 30); sticky(eqKoch); hidden(eqKoch);
+// the closing paradox — the one genuine gasp
+equation(eqPar, (cx, h - 120), `\text{perimeter } 3\left(\tfrac{4}{3}\right)^{n}\!\to\infty \qquad \text{area}\to \tfrac{8}{5}A_0`, 34); sticky(eqPar); hidden(eqPar);
+
+// hidden journey axes (the sliders stay backstage — the dive/angle drive the shaders)
+parameter(dive, (w - 180, 660), 0, 0, 1, "dive", 2); hidden(dive);
+parameter(ang, (w - 180, 690), 0, 0, 6.283, "angle", 2); hidden(ang);
+
+// ---------- I. the Mandelbrot coastline ----------
+shader(mset) {
+  let sc = 3.2 * exp(-6.2 * dive);
+  let x = -0.743644 + (u - 0.5) * asp * sc;
+  let y = 0.131826 + (v - 0.5) * sc;
+  let m = mandelbrot(x, y);
+  let band = m^0.35;
+  let hue = 205 + 140 * band + 25 * sin(0.3 * t);
+  let sat = 0.75;
+  let val = (1 - step(0.999, m)) * (0.12 + 0.88 * band);
+}
+
+// ---------- II. the Julia bloom ----------
+shader(jul) {
+  let x = (u - 0.5) * asp * 2.9;
+  let y = (v - 0.5) * 2.9;
+  let cr = 0.7885 * cos(ang);
+  let ci = 0.7885 * sin(ang);
+  let j = julia(x, y, cr, ci);
+  let band = j^0.4;
+  let hue = 290 + 120 * band + 15 * sin(0.4 * t);
+  let sat = 0.8;
+  let val = (1 - step(0.999, j)) * (0.1 + 0.9 * band);
+}
+hidden(jul);
+
+// ---------- III. the strange attractor (Clifford, a=-1.4 b=1.6 c=1 d=0.7) ----
+cloud(att, 6000, #ffffff, 0.85) from map("sin(-1.4*y)+cos(-1.4*x)", "sin(1.6*x)+0.7*cos(1.6*y)", (0.1, 0.1)) {
+  let wsp = 0.12 * t;
+  let px = hx * cos(wsp) - hy * sin(wsp);
+  let py = hx * sin(wsp) + hy * cos(wsp);
+  let x = 640 + 225 * px;        // cloud formulas can't see cx/cy — hardcode the 16:9 centre
+  let y = 360 + 15 + 165 * py;
+  let r = 1.1 + 0.8 * mod(abs(sin(i * 12.9898) * 43758.55), 1);
+  let hue = 150 + 60 * hypot(hx, hy) + 25 * sin(0.4 * t + 0.002 * i);
+}
+hidden(att);
+
+// ---------- IV. the snowflake (Koch, one closed stroke) ----------
+lsystem(koch, (cx, cy + 20), 560, "F--F--F", "F=F+F--F+F", "angle=60 iterations=4 closed=true");
+untraced(koch); stroke(koch, 3); gradient(koch, cyan, magenta, gold);
+
+// the four fullscreen visuals sit BEHIND the HUD (all default to z=0, so without
+// this the later-declared shader would paint over the teaching panel + captions)
+z(mset, -3); z(jul, -3); z(att, -3); z(koch, -2);
+
+// ================= timeline =================
+
+// ---- I: ∞ by ZOOM — the Mandelbrot dive
+type(head, 1.2);
+par { show(panel, 0.4); show(kind1, 0.4); show(mag, 0.3); }
+show(eqIter, 0.6);
+par {
+  to(dive, value, 1, 12, smooth);
+  to(mag, value, 500, 12, smooth);
+  seq {
+    say(cap, "the Mandelbrot set: keep the points where z → z² + c never flies to infinity", 0.6);
+    wait(4.6);
+    say(cap, "zoom 500x and the coastline keeps unfolding — new seahorses, never one exact repeat", 0.5);
+    wait(4.2);
+  }
+}
+cue(whoosh);
+
+// ---- bridge: the Mandelbrot set IS the map of Julia sets
+say(cap, "here is the secret: every point c in that black island grows its OWN fractal...", 0.5);
+wait(3.2);
+
+// ---- II: ∞ by PARAMETER — same rule, c is the knob
+par { fade(mset, 1.2); fade(mag, 0.6); fade(kind1, 0.3); show(jul, 1.2); show(kind2, 0.4); }
+show(eqC, 0.5);           // eqIter STAYS on screen — same rule, bridging I and II
+par {
+  to(ang, value, 6.283, 12, linear);
+  seq {
+    say(cap, "...a Julia set. Freeze z's rule, make c the knob: c inside the set → connected, outside → dust", 0.5);
+    wait(5.0);
+    say(cap, "slide c around a circle and every value is a different universe — same equation, new world", 0.5);
+    wait(4.6);
+  }
+}
+cue(whoosh);
+
+// ---- III: ∞ by ITERATION — a rule fed its own output
+par { fade(jul, 1.4); fade(kind2, 0.3); fade(eqIter, 0.3); fade(eqC, 0.3); show(att, 1.6); show(kind3, 0.4); }
+show(eqCliff, 0.5);
+say(cap, "no formula draws this shape — just this rule, fed its own output six thousand times", 0.5);
+wait(4.0);
+say(cap, "nudge one constant and it's a whole new creature: that sensitivity IS chaos", 0.5);
+wait(3.4);
+cue(whoosh);
+
+// ---- IV: ∞ by RECURSION — the snowflake, and the paradox
+par { fade(att, 1.2); fade(kind3, 0.3); fade(eqCliff, 0.3); show(kind4, 0.4); }
+show(eqKoch, 0.5);
+say(cap, "some infinities you draw with one stroke: replace every edge with four, forever", 0.5);
+draw(koch, 6.0);
+par { cam((cx + 215, cy - 100), 1.6, smooth); zoom(2.8, 1.6, smooth); }
+say(cap, "look closer — the edge is made of smaller edges, at every scale", 0.5);
+wait(2.6);
+par { cam((cx, cy), 1.5, smooth); zoom(1, 1.5, smooth); }
+// the payoff: infinite perimeter, finite area
+show(eqPar, 0.8);
+say(cap, "the perimeter grows x4/3 every step — to INFINITY — yet the whole shape fits in a circle", 0.6);
+wait(3.4);
+cue(chime);
+say(cap, "four rules, four infinities — and you are never done looking", 0.7);
+wait(3.2);

package/examples/lsystem-asymptote-curves.manic

@@ -0,0 +1,81 @@
+// Four classic deterministic curves from the Asymptote example corpus.
+// Each figure is one fitted, traceable Manic entity—even the 9,604-segment curve.
+
+title("Four Rules, Four Infinite-Looking Curves");
+canvas("16:9");
+template("mono");
+
+watermark(mark, (w*0.105, h*0.08), "Made With Manic");
+text(kicker, (cx, h*0.075), "GENERATIVE GEOMETRY · L-SYSTEMS");
+text(headline, (cx, h*0.135), "A tiny rewriting rule becomes a continuous path");
+text(caption, (cx, h*0.92), "One path per curve · auto-fitted · continuously drawable");
+size(kicker, 20); bold(kicker); color(kicker, dim);
+size(headline, 34); bold(headline);
+size(caption, 20); color(caption, dim);
+
+let left = w*0.275;
+let right = w*0.725;
+let upper = h*0.37;
+let lower = h*0.70;
+let cell = h*0.27;
+
+lsystem(sierpinski, (left, upper), cell,
+  "YF", "X=YF+XF+Y;Y=XF-YF-X",
+  "angle=60 heading=0 iterations=7");
+color(sierpinski, cyan); stroke(sierpinski, 2.5); untraced(sierpinski);
+
+lsystem(gosper, (right, upper), cell,
+  "FX", "X=X+YF++YF-FX--FXFX-YF+;Y=-FX+YFYF++YF+FX--FX-Y",
+  "angle=60 heading=0 iterations=4");
+color(gosper, magenta); stroke(gosper, 2.5); untraced(gosper);
+
+lsystem(squareCurve, (left, lower), cell,
+  "F+XF+F+XF", "X=XF-F+F-XF+F+XF-F+F-X",
+  "angle=90 heading=45 iterations=5 closed=true fill=true");
+color(squareCurve, gold); opacity(squareCurve, 0.70); stroke(squareCurve, 2.0); untraced(squareCurve);
+
+lsystem(carpet, (right, lower), cell,
+  "F+F+F+F", "F=FF+F+F+F+FF",
+  "angle=90 heading=0 iterations=4");
+color(carpet, lime); stroke(carpet, 2.0); untraced(carpet);
+
+text(l1, (left, h*0.205), "SIERPINSKI CURVE · 2,187 SEGMENTS");
+text(l2, (right, h*0.205), "PEANO–GOSPER · 2,401 SEGMENTS");
+text(l3, (left, h*0.535), "SQUARE CURVE · 5,460 SEGMENTS");
+text(l4, (right, h*0.535), "CARPET CURVE · 9,604 SEGMENTS");
+size(l1, 18); size(l2, 18); size(l3, 18); size(l4, 18);
+bold(l1); bold(l2); bold(l3); bold(l4);
+color(l1, cyan); color(l2, magenta); color(l3, gold); color(l4, lime);
+hidden(l1); hidden(l2); hidden(l3); hidden(l4);
+
+step("one rule becomes a curve") {
+  par {
+    show(l1, 0.35);
+    draw(sierpinski, 1.8, smooth);
+  }
+}
+wait(0.30);
+
+step("change the grammar") {
+  par {
+    show(l2, 0.35);
+    draw(gosper, 1.8, smooth);
+  }
+}
+wait(0.30);
+
+step("close and fill the boundary") {
+  par {
+    show(l3, 0.35);
+    draw(squareCurve, 1.8, smooth);
+  }
+}
+wait(0.30);
+
+step("thousands of segments stay one path") {
+  par {
+    show(l4, 0.35);
+    draw(carpet, 2.2, smooth);
+  }
+}
+wait(1.20);

package/examples/manic-ml-activation-focus.manic

@@ -0,0 +1,133 @@
+// manic-ml-activation-focus.manic — one ML noun, one complete lesson
+// `activation` supplies the truthful ReLU curve. Core Manic supplies the
+// question, equation, input probes, local emphasis, timing, and takeaway.
+
+title("Manic ML — Why ReLU Changes a Neuron");
+canvas("16:9");
+template("mono");
+
+creator(me, "@anish2good name=Manic_ML tagline=Models_made_visible yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=cyan secondary=magenta footer=compact cta=See_the_rule safe=clean");
+socials(me);
+
+let u = (w+h-abs(w-h))/1440;
+
+if h > 1.45*w {
+  watermark(manicMark, (w*0.15, h*0.06), "Made With Manic");
+  text(kicker, (cx, h*0.065), "MANIC ML · ACTIVATION");
+  text(headline, (cx, h*0.11), "Why does a neuron need ReLU?");
+  text(caption, (cx, h*0.79), "A neuron first receives an unrestricted number.");
+  equation(rule, (cx, h*0.60), `\operatorname{ReLU}(x)=\max(0,x)`, 35*u);
+
+  activation(reluView, (cx, h*0.38), relu, w*0.74, h*0.22);
+  line(negativePath, (w*0.13, h*0.466), (cx, h*0.466));
+  line(positivePath, (cx, h*0.466), (w*0.87, h*0.27));
+  line(positiveGuide, (w*0.685, h*0.466), (w*0.685, h*0.368));
+  circle(negativeProbe, (w*0.315, h*0.466), 8*u);
+  circle(positiveProbe, (w*0.685, h*0.368), 8*u);
+  text(negativeNote, (w*0.27, h*0.525), "x = −2  →  0");
+  text(positiveNote, (w*0.73, h*0.525), "x = 2  →  2");
+}
+else if w > 1.25*h {
+  watermark(manicMark, (w*0.17, h*0.09), "Made With Manic");
+  text(kicker, (cx, h*0.075), "MANIC ML · ACTIVATION");
+  text(headline, (cx, h*0.14), "Why does a neuron need ReLU?");
+  text(caption, (cx, h*0.82), "A neuron first receives an unrestricted number.");
+  equation(rule, (w*0.79, h*0.36), `\operatorname{ReLU}(x)=\max(0,x)`, 34*u);
+
+  activation(reluView, (w*0.38, h*0.49), relu, w*0.52, h*0.48);
+  line(negativePath, (w*0.12, h*0.677), (w*0.38, h*0.677));
+  line(positivePath, (w*0.38, h*0.677), (w*0.64, h*0.25));
+  line(positiveGuide, (w*0.51, h*0.677), (w*0.51, h*0.463));
+  circle(negativeProbe, (w*0.25, h*0.677), 8*u);
+  circle(positiveProbe, (w*0.51, h*0.463), 8*u);
+  text(negativeNote, (w*0.79, h*0.50), "x = −2  →  0");
+  text(positiveNote, (w*0.79, h*0.59), "x = 2  →  2");
+}
+else {
+  watermark(manicMark, (w*0.18, h*0.08), "Made With Manic");
+  text(kicker, (cx, h*0.06), "MANIC ML · ACTIVATION");
+  text(headline, (cx, h*0.145), "Why does a neuron need ReLU?");
+  text(caption, (cx, h*0.82), "A neuron first receives an unrestricted number.");
+  equation(rule, (cx, h*0.67), `\operatorname{ReLU}(x)=\max(0,x)`, 34*u);
+
+  activation(reluView, (cx, h*0.40), relu, w*0.72, h*0.28);
+  line(negativePath, (w*0.14, h*0.509), (cx, h*0.509));
+  line(positivePath, (cx, h*0.509), (w*0.86, h*0.26));
+  line(positiveGuide, (w*0.68, h*0.509), (w*0.68, h*0.384));
+  circle(negativeProbe, (w*0.32, h*0.509), 8*u);
+  circle(positiveProbe, (w*0.68, h*0.384), 8*u);
+  text(negativeNote, (w*0.27, h*0.58), "x = −2  →  0");
+  text(positiveNote, (w*0.73, h*0.58), "x = 2  →  2");
+}
+
+size(kicker, 19*u); color(kicker, dim); bold(kicker); hidden(kicker);
+size(headline, 34*u); bold(headline); wrap(headline, w*0.82); hidden(headline);
+size(caption, 21*u); color(caption, dim); wrap(caption, w*0.78); hidden(caption);
+hidden(rule);
+
+color(negativePath, magenta); stroke(negativePath, 5*u); glow(negativePath, 0.35); untraced(negativePath);
+color(positivePath, cyan); stroke(positivePath, 5*u); glow(positivePath, 0.35); untraced(positivePath);
+color(positiveGuide, dim); stroke(positiveGuide, 2*u); dashed(positiveGuide, 9*u, 7*u); untraced(positiveGuide);
+
+color(negativeProbe, magenta); filled(negativeProbe); glow(negativeProbe, 0.55); hidden(negativeProbe);
+color(positiveProbe, cyan); filled(positiveProbe); glow(positiveProbe, 0.55); hidden(positiveProbe);
+size(negativeNote, 18*u); color(negativeNote, magenta); bold(negativeNote); hidden(negativeNote);
+size(positiveNote, 18*u); color(positiveNote, cyan); bold(positiveNote); hidden(positiveNote);
+
+untraced(reluView.axes);
+untraced(reluView.curve);
+hidden(reluView.label);
+
+step("question") {
+  show(kicker, 0.35);
+  show(headline, 0.45);
+  show(caption, 0.40);
+  draw(reluView.axes, 0.75);
+}
+wait(0.55);
+
+step("rule") {
+  show(rule, 0.55);
+  say(caption, "ReLU makes one transparent promise: return the larger of zero and x.", 0.40);
+}
+wait(0.55);
+
+step("negative-input") {
+  par {
+    draw(negativePath, 0.75);
+    show(negativeProbe, 0.35);
+    show(negativeNote, 0.35);
+    say(caption, "Negative input is muted at zero; it cannot send negative evidence onward.", 0.40);
+  }
+}
+wait(0.65);
+
+step("positive-input") {
+  par {
+    draw(positivePath, 0.85);
+    draw(positiveGuide, 0.55);
+    show(positiveProbe, 0.35);
+    show(positiveNote, 0.35);
+    say(caption, "Positive input passes through unchanged, preserving its strength.", 0.40);
+  }
+}
+wait(0.70);
+
+step("activation") {
+  par {
+    draw(reluView.curve, 1.10);
+    show(reluView.label, 0.35);
+    say(caption, "That small bend gives a network a nonlinear decision boundary.", 0.40);
+    par { cam((cx, h*0.47), 0.70, smooth); zoom(1.10, 0.70, smooth); }
+  }
+}
+wait(0.75);
+
+step("takeaway") {
+  par {
+    pulse(reluView.curve, 0.75);
+    say(caption, "ReLU does not invent a signal: it gates what the neuron already computed.", 0.45);
+    par { cam((cx, cy), 0.70, smooth); zoom(1.0, 0.70, smooth); }
+  }
+}
+wait(1.50);

package/examples/manic-ml-cnn-edge-story.manic

@@ -0,0 +1,102 @@
+// manic-ml-cnn-edge-story.manic — ML3 creator proof
+// A tiny image becomes a feature map and then a pooled summary. Every number is
+// computed by Manic; scan coordinates the receptive field and destination.
+
+title("Manic ML — How a CNN Finds an Edge");
+canvas("16:9");
+template("mono");
+
+creator(me, "@anish2good name=Manic_ML tagline=Models_made_visible yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=cyan secondary=magenta footer=compact cta=See_the_feature safe=clean");
+socials(me);
+
+let u = (w+h-abs(w-h))/1440;
+let cell = 48*u;
+
+if h > 1.45*w {
+  watermark(manicMark, (w*0.13, h*0.075), "Made With Manic");
+  text(kicker, (cx, h*0.08), "MANIC ML · CONVOLUTION");
+  text(headline, (cx, h*0.13), "How does a CNN see edges?");
+  text(caption, (cx, h*0.72), "Start with a tiny image: bright cells form a simple shape.");
+  tensor(image, (w*0.28, h*0.35), "0 0 0 0 0; 0 0 1 1 0; 0 1 1 1 0; 0 0 1 1 0; 0 0 0 0 0", cell, cyan);
+  kernel(edge, (w*0.72, h*0.35), "-1 0 1; -2 0 2; -1 0 1", cell, magenta);
+  convolve(feature, image, edge, (w*0.34, h*0.54), 1, 0, 0, relu, cell);
+  pool(pooled, feature, (w*0.72, h*0.54), max, 2, 1, 0, cell);
+}
+else if w > 1.25*h {
+  watermark(manicMark, (w*0.18, h*0.10), "Made With Manic");
+  text(kicker, (cx, h*0.075), "MANIC ML · CONVOLUTION");
+  text(headline, (cx, h*0.14), "How does a CNN see edges?");
+  text(caption, (cx, h*0.82), "Start with a tiny image: bright cells form a simple shape.");
+  tensor(image, (w*0.17, h*0.47), "0 0 0 0 0; 0 0 1 1 0; 0 1 1 1 0; 0 0 1 1 0; 0 0 0 0 0", cell, cyan);
+  kernel(edge, (w*0.42, h*0.47), "-1 0 1; -2 0 2; -1 0 1", cell, magenta);
+  convolve(feature, image, edge, (w*0.68, h*0.47), 1, 0, 0, relu, cell);
+  pool(pooled, feature, (w*0.89, h*0.47), max, 2, 1, 0, cell);
+}
+else {
+  watermark(manicMark, (w*0.18, h*0.08), "Made With Manic");
+  text(kicker, (cx, h*0.07), "MANIC ML · CONVOLUTION");
+  text(headline, (cx, h*0.13), "How does a CNN see edges?");
+  text(caption, (cx, h*0.82), "Start with a tiny image: bright cells form a simple shape.");
+  tensor(image, (w*0.18, h*0.44), "0 0 0 0 0; 0 0 1 1 0; 0 1 1 1 0; 0 0 1 1 0; 0 0 0 0 0", cell, cyan);
+  kernel(edge, (w*0.45, h*0.44), "-1 0 1; -2 0 2; -1 0 1", cell, magenta);
+  convolve(feature, image, edge, (w*0.70, h*0.44), 1, 0, 0, relu, cell);
+  pool(pooled, feature, (w*0.89, h*0.44), max, 2, 1, 0, cell);
+}
+
+size(kicker, 20*u); color(kicker, dim); bold(kicker); hidden(kicker);
+size(headline, 35*u); bold(headline); wrap(headline, w*0.82); hidden(headline);
+size(caption, 22*u); color(caption, dim); wrap(caption, w*0.78); hidden(caption);
+hidden(image); hidden(edge); hidden(feature); hidden(pooled);
+
+step("pixels") {
+  show(kicker, 0.35);
+  show(headline, 0.45);
+  show(caption, 0.40);
+  show(image, 0.65);
+}
+wait(0.55);
+
+step("edge-detector") {
+  show(edge, 0.55);
+  say(caption, "This 3×3 kernel compares the left side of each patch with the right.", 0.40);
+}
+wait(0.55);
+
+step("feature-map") {
+  show(feature, 0.50);
+  say(caption, "The feature map begins quiet; each destination waits for one receptive field.", 0.40);
+}
+wait(0.35);
+
+step("convolution-scan") {
+  par {
+    scan(feature, 4.80, smooth);
+    say(caption, "The same kernel slides, multiplies, sums, applies ReLU, and writes one cell.", 0.40);
+    seq {
+      par { cam((w*0.38, h*0.45), 0.75, smooth); zoom(1.10, 0.75, smooth); }
+      wait(2.95);
+      par { cam((cx, cy), 0.85, smooth); zoom(1.0, 0.85, smooth); }
+    }
+  }
+}
+wait(0.60);
+
+step("pooling-map") {
+  show(pooled, 0.50);
+  say(caption, "Max pooling asks a simpler question: where is the strongest local evidence?", 0.40);
+}
+wait(0.40);
+
+step("pooling-scan") {
+  par {
+    scan(pooled, 3.40, smooth);
+    say(caption, "Each 2×2 window keeps its first maximum; ties are deterministic.", 0.40);
+  }
+}
+wait(0.70);
+
+step("takeaway") {
+  pulse(pooled.cells, 0.75);
+  say(caption, "A CNN builds meaning locally: pixels → feature responses → compact evidence.", 0.45);
+}
+wait(1.50);

package/examples/manic-ml-forward-pass.manic

@@ -0,0 +1,93 @@
+// manic-ml-forward-pass.manic — ML1 creator proof
+// A real deterministic network computes one prediction. The story keeps the
+// model persistent and reveals only the active computation instead of flashing
+// every connection at once.
+
+title("Manic ML — A Forward Pass You Can Follow");
+canvas("16:9");
+template("mono");
+
+creator(me, "@anish2good name=Manic_ML tagline=Models_made_visible yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=cyan secondary=magenta footer=compact cta=See_the_computation safe=clean");
+socials(me);
+
+let u = (w+h-abs(w-h))/1440;
+
+// One story reflows to portrait, feed, square, and landscape. The portrait
+// network narrows to reserve a clean probability lane at the right.
+if h > 1.45*w {
+  watermark(manicMark, (w*0.18, h*0.075), "Made With Manic");
+  text(kicker, (cx, h*0.08), "MANIC ML · FORWARD PASS");
+  text(headline, (cx, h*0.13), "How does a network choose?");
+  text(caption, (cx, h*0.72), "First, a neuron keeps positive evidence and removes negative evidence.");
+  activation(reluView, (cx, h*0.40), relu, w*0.72, h*0.24);
+  network(model, (cx, h*0.42), "3 6 4 3", "relu tanh softmax", w*0.55, h*0.32, 21);
+}
+else if w > 1.25*h {
+  watermark(manicMark, (w*0.18, h*0.10), "Made With Manic");
+  text(kicker, (cx, h*0.075), "MANIC ML · FORWARD PASS");
+  text(headline, (cx, h*0.14), "How does a network choose?");
+  text(caption, (cx, h*0.83), "First, a neuron keeps positive evidence and removes negative evidence.");
+  activation(reluView, (cx, h*0.49), relu, w*0.42, h*0.36);
+  network(model, (cx, h*0.47), "3 6 4 3", "relu tanh softmax", w*0.64, h*0.39, 21);
+}
+else {
+  watermark(manicMark, (w*0.18, h*0.08), "Made With Manic");
+  text(kicker, (cx, h*0.07), "MANIC ML · FORWARD PASS");
+  text(headline, (cx, h*0.13), "How does a network choose?");
+  text(caption, (cx, h*0.82), "First, a neuron keeps positive evidence and removes negative evidence.");
+  activation(reluView, (cx, h*0.43), relu, w*0.68, h*0.30);
+  network(model, (cx, h*0.45), "3 6 4 3", "relu tanh softmax", w*0.64, h*0.40, 21);
+}
+
+size(kicker, 20*u); color(kicker, dim); bold(kicker); hidden(kicker);
+size(headline, 36*u); bold(headline); hidden(headline);
+size(caption, 22*u); color(caption, dim); wrap(caption, w*0.78); hidden(caption);
+
+// A truthful ReLU curve introduces the operation used by the hidden layer.
+hidden(reluView);
+untraced(reluView.axes);
+untraced(reluView.curve);
+
+// 3 inputs → 6 ReLU units → 4 tanh units → 3 softmax probabilities.
+// Seed 21 makes the educational model reproducible across every render.
+hidden(model);
+
+step("activation") {
+  show(kicker, 0.35);
+  show(headline, 0.45);
+  show(caption, 0.40);
+  show(reluView, 0.55);
+  draw(reluView.axes, 0.70);
+  draw(reluView.curve, 1.20);
+}
+wait(0.75);
+
+step("meet-the-network") {
+  fade(reluView, 0.45);
+  show(model, 0.65);
+  say(caption, "The same operation now lives inside a small, deterministic network.", 0.45);
+}
+wait(0.65);
+
+step("forward-pass") {
+  par {
+    forward(model, "0.15 0.92 0.38", 4.20, smooth);
+    say(caption, "Follow the bright path: inputs become evidence, then probabilities.", 0.45);
+    seq {
+      par { cam((w*0.24, h*0.47), 0.55, smooth); zoom(1.06, 0.55, smooth); }
+      wait(0.55);
+      cam((cx, h*0.47), 0.80, smooth);
+      wait(0.55);
+      cam((w*0.76, h*0.47), 0.80, smooth);
+      wait(0.40);
+      par { cam((cx, cy), 0.55, smooth); zoom(1.0, 0.55, smooth); }
+    }
+  }
+}
+wait(0.90);
+
+step("takeaway") {
+  pulse(model.output, 0.75);
+  say(caption, "The picture is driven by the computed values—not a decorative animation.", 0.45);
+}
+wait(1.60);

package/examples/manic-ml-learning-step.manic

@@ -0,0 +1,116 @@
+// manic-ml-learning-step.manic — ML2 creator proof
+// One persistent network predicts, measures its mistake, sends exact gradients
+// backward, changes its parameters, then rolls that one saved change back.
+// No layer is cleared and redrawn; rollback is not claimed as full unlearning.
+
+title("Manic ML — How One Mistake Becomes Learning");
+canvas("16:9");
+template("mono");
+
+creator(me, "@anish2good name=Manic_ML tagline=Models_made_visible yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=cyan secondary=magenta footer=compact cta=See_the_learning safe=clean");
+socials(me);
+
+let u = (w+h-abs(w-h))/1440;
+
+if h > 1.45*w {
+  watermark(manicMark, (w*0.13, h*0.075), "Made With Manic");
+  text(kicker, (cx, h*0.08), "MANIC ML · ONE LEARNING STEP");
+  text(headline, (cx, h*0.13), "How does a model learn?");
+  text(caption, (cx, h*0.72), "First the network predicts from the current weights.");
+  network(model, (cx, h*0.42), "3 6 4 3", "relu tanh softmax", w*0.55, h*0.32, 21);
+}
+else if w > 1.25*h {
+  watermark(manicMark, (w*0.18, h*0.10), "Made With Manic");
+  text(kicker, (cx, h*0.075), "MANIC ML · ONE LEARNING STEP");
+  text(headline, (cx, h*0.14), "How does a model learn?");
+  text(caption, (cx, h*0.83), "First the network predicts from the current weights.");
+  network(model, (cx, h*0.47), "3 6 4 3", "relu tanh softmax", w*0.64, h*0.39, 21);
+}
+else {
+  watermark(manicMark, (w*0.18, h*0.08), "Made With Manic");
+  text(kicker, (cx, h*0.07), "MANIC ML · ONE LEARNING STEP");
+  text(headline, (cx, h*0.13), "How does a model learn?");
+  text(caption, (cx, h*0.82), "First the network predicts from the current weights.");
+  network(model, (cx, h*0.45), "3 6 4 3", "relu tanh softmax", w*0.64, h*0.40, 21);
+}
+
+size(kicker, 20*u); color(kicker, dim); bold(kicker); hidden(kicker);
+size(headline, 35*u); bold(headline); wrap(headline, w*0.82); hidden(headline);
+size(caption, 22*u); color(caption, dim); wrap(caption, w*0.78); hidden(caption);
+hidden(model);
+
+step("question") {
+  show(kicker, 0.35);
+  show(headline, 0.45);
+  show(caption, 0.40);
+  show(model, 0.65);
+}
+wait(0.55);
+
+step("predict") {
+  par {
+    forward(model, "0.15 0.92 0.38", 3.20, smooth);
+    say(caption, "A forward pass turns the input into three probabilities.", 0.40);
+  }
+}
+wait(0.55);
+
+step("measure-the-mistake") {
+  par {
+    loss(model, "1 0 0", crossentropy, 1.50, smooth);
+    say(caption, "The correct answer is class 1. Cross-entropy measures the mismatch.", 0.40);
+  }
+}
+wait(0.55);
+
+step("send-credit-backward") {
+  par {
+    backward(model, 3.20, smooth);
+    say(caption, "The gradient carries responsibility backward through the same connections.", 0.40);
+    seq {
+      par { cam((w*0.76, h*0.47), 0.40, smooth); zoom(1.08, 0.40, smooth); }
+      wait(0.30);
+      cam((cx, h*0.47), 0.55, smooth);
+      wait(0.25);
+      cam((w*0.24, h*0.47), 0.55, smooth);
+      wait(0.25);
+      par { cam((cx, cy), 0.45, smooth); zoom(1.0, 0.45, smooth); }
+    }
+  }
+}
+wait(0.55);
+
+// A zero-duration authored checkpoint captures the exact pre-update weights,
+// prediction, target, and loss. It does not add a hidden runtime state.
+checkpoint(beforeUpdate, model);
+
+step("learn") {
+  par {
+    update(model, 0.18, 2.30, smooth);
+    say(caption, "Each parameter moves opposite its gradient; the same input is computed again.", 0.40);
+  }
+}
+wait(0.70);
+
+step("unlearn") {
+  par {
+    restore(model, beforeUpdate, 2.30, smooth);
+    say(caption, "Exact rollback restores the saved parameters and their earlier prediction.", 0.40);
+    seq {
+      par { cam((w*0.24, h*0.47), 0.40, smooth); zoom(1.08, 0.40, smooth); }
+      wait(0.30);
+      cam((cx, h*0.47), 0.55, smooth);
+      wait(0.25);
+      cam((w*0.76, h*0.47), 0.55, smooth);
+      wait(0.25);
+      par { cam((cx, cy), 0.45, smooth); zoom(1.0, 0.45, smooth); }
+    }
+  }
+}
+wait(0.70);
+
+step("takeaway") {
+  pulse(model.output, 0.75);
+  say(caption, "This undoes one saved update. Dataset-level unlearning is a different process.", 0.45);
+}
+wait(1.50);