@maniclang/workbench 0.1.11

package/examples/creator-lattice-paths.manic

@@ -0,0 +1,118 @@
+// Lattice-path counting — "how many ways from corner to corner moving only right
+// and down?" The SAME recurrence as Pascal (cell = the one above + the one to the
+// left) but on a RECTANGLE — so it uses the grid kit. Each cell's count is a `prod`
+// reduction (C(i+j,i)); afterwards one actual path is traced with `spline`.
+// Different template (blueprint) + different typewriter (a question that erases and
+// retypes into its answer).
+title("Lattice Paths");
+canvas("9:16");
+template("blueprint");
+
+creator(me, "@anish2good name=Manic tagline=Turn_plain_text_into_amazing_math_videos yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=cyan secondary=gold footer=signature cta=Try_it_free safe=reels");
+watermark(manicMark, (w*0.955-100, h*0.045+24), "Made With Manic");
+
+let C = 5;          // columns of cells
+let R = 4;          // rows of cells
+let s = w*0.162;    // cell size
+let gy = h*0.455;   // grid centre y
+let ox = cx - C*s*0.5;
+let oy = gy - R*s*0.5;
+
+// The rectangular lattice IS a grid-kit grid. Overlay a path-count on every cell:
+// value(i,j) = C(i+j, i), the number of monotone right/down paths reaching it.
+grid(lat, (cx, gy), C, R, s);
+opacity(lat.cells, 0);   // a lattice is its lines — clear the cell fills so the counts read
+for i in 0..R {
+  for j in 0..C {
+    let val = prod(t in 1..i+1 : (j+t)/t);   // C(i+j, i)
+    counter(pc{i}_{j}, (ox+(j+0.5)*s, oy+(i+0.5)*s), val, 0);
+    tag(pc{i}_{j}, pathnums); tag(pc{i}_{j}, prow{i});
+  }
+}
+
+// One monotone path (right/right/down/right/down/right/down) traced afterward.
+spline(route,
+  (ox+0.5*s, oy+0.5*s), (ox+1.5*s, oy+0.5*s), (ox+2.5*s, oy+0.5*s),
+  (ox+2.5*s, oy+1.5*s), (ox+3.5*s, oy+1.5*s), (ox+3.5*s, oy+2.5*s),
+  (ox+4.5*s, oy+2.5*s), (ox+4.5*s, oy+3.5*s));
+color(route, gold); stroke(route, 7); glow(route, 0.8); untraced(route); hidden(route);
+
+// --- text: a question that later erases and retypes into the answer ---
+text(kicker, (cx, h*0.115), "How many paths, corner to corner?");
+size(kicker, 33); color(kicker, cyan); bold(kicker); wrap(kicker, w*0.86);
+text(sub, (cx, h*0.165), "moving only RIGHT and DOWN");
+size(sub, 27); color(sub, dim);
+text(answer, (cx, h*0.13), "35 paths — every one of them counted.");
+size(answer, 34); color(answer, gold); bold(answer); wrap(answer, w*0.86);
+text(cap, (cx, h*0.80), "each cell counts the ways to reach it");
+size(cap, 31); color(cap, dim); wrap(cap, w*0.84);
+
+socials(me);
+endcard(me, "title=Try_Manic cta=8gwifi.org/manic");
+
+hidden(pathnums); hidden(cap);
+untraced(kicker); cursor(kicker);
+untraced(sub);
+untraced(answer); hidden(answer);
+
+// 1 — HOOK: the question types on (two lines), then the lattice fills in.
+mark("hook");
+type(kicker, 1.2);
+type(sub, 0.9);
+show(cap, 0.4);
+for i in 0..R { show(prow{i}, 0.3); wait(0.12); }
+wait(0.4);
+
+// 2 — THE RULE: 4 + 6 = 10 — every cell is (the one above) + (the one to the left).
+step("rule") {
+  seq {
+    say(cap, "= the cell above  +  the cell to its left   (4 + 6 = 10)");
+    par { flash(pc1_3, cyan); flash(pc2_2, cyan); }
+    flash(pc2_3, gold);
+  }
+}
+wait(0.5);
+
+// 3 — THE ANSWER: the far corner holds the total. The question erases & retypes.
+step("answer") {
+  seq {
+    par { erase(kicker, 0.5); erase(sub, 0.4); }
+    fade(kicker, 0.15);   // clear the residual typewriter cursor left after erase
+    par {
+      pulse(pc3_4, 0.8);
+      flash(pc3_4, gold);
+      show(answer, 0.1);
+      type(answer, 1.1);
+    }
+    say(cap, "and every path is a right/down staircase");
+  }
+}
+wait(0.5);
+
+// 4 — TRACE ONE: draw an actual corner-to-corner path with a spline.
+step("trace") {
+  par {
+    show(route, 0.2);
+    draw(route, 1.6);
+  }
+}
+wait(0.7);
+
+// 5 — THE POINT: one script did the grid, the counting AND the path.
+step("power") {
+  seq {
+    say(cap, "one short script: the grid, the counting, and the path");
+    par { pulse(pathnums, 0.7); recolor(cap, cyan); }
+    say(cap, "Manic animates math, physics, algorithms & more — from plain text");
+  }
+}
+wait(1.3);
+
+// 6 — END CARD.
+mark("endcard");
+par {
+  fade(answer, 0.4); fade(cap, 0.4); fade(me.footer, 0.4);
+  fade(pathnums, 0.4); fade(lat.cells, 0.4); fade(lat.lines, 0.4); fade(route, 0.4);
+}
+show(me.endcard, 0.6);
+wait(1.6);

package/examples/creator-line-inversion.manic

@@ -0,0 +1,49 @@
+// Existing-Manic treatment of animations/fig0030.asy.
+// A line not through the inversion center becomes a circle through the center.
+
+title("Line Inversion");
+canvas("9:16");
+template("black");
+creator(me,"@anish2good name=Manic_Geometry tagline=Transformation_stories yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=magenta secondary=cyan footer=compact cta=See_the_mapping safe=clean");
+socials(me);
+watermark(mark,(w*0.16,h*0.055),"Made With Manic");
+endcard(me,"title=Animate_Geometry_Not_Keyframes cta=8gwifi.org/manic");
+
+let u=(w+h-abs(w-h))/1080; let oy=h*0.48; let R=120*u;
+text(kicker,(cx,h*0.10),"UNIT-CIRCLE INVERSION");
+text(head,(cx,h*0.17),"Where does the line x = 2 go?");
+text(caption,(cx,h*0.79),"Every image point obeys OP · OP′ = 1.");
+equation(eq,(cx,h*0.72),`x=2\quad\longmapsto\quad(x-\tfrac14)^2+y^2=(\tfrac14)^2`,29*u);
+size(kicker,20*u); bold(kicker); color(kicker,magenta);
+size(head,27*u); bold(head); wrap(head,w*0.76);
+size(caption,20*u); bold(caption); wrap(caption,w*0.74); color(caption,dim);
+
+circle(unit,(cx-R,oy),R); outlined(unit); outline(unit,cyan); color(unit,panel);
+dot(O,(cx-R,oy),8*u); color(O,gold);
+line(source,(cx+R,oy-1.45*R),(cx+R,oy+1.45*R)); color(source,magenta); stroke(source,4);
+invertpath(image,source,O,R,360); outline(image,lime); color(image,lime); stroke(image,4);
+untraced(unit); untraced(source); untraced(image); hidden(O); hidden(kicker); hidden(head); hidden(caption); hidden(eq);
+
+step("pose") { par { show(kicker,0.3); show(head,0.4); show(caption,0.35); draw(unit,0.65,smooth); show(O,0.2); draw(source,0.6,smooth); } }
+wait(0.85);
+step("map three points") { say(caption,"Points far away move near O; the midpoint (2,0) maps to (1/2,0).",0.45,smooth); }
+wait(0.9);
+step("follow the limiting point") {
+  par {
+    pulse(O,0.80);
+    say(caption,"As a source point runs to infinity, its image approaches O; that is why the image circle passes through O.",0.65,smooth);
+  }
+}
+wait(1.0);
+step("join the images") {
+  par { draw(image,0.75,smooth); fade(source,0.35); show(eq,0.45); say(caption,"Those image points lie on one circle through O.",0.4); }
+}
+wait(0.95);
+step("check the equation") {
+  say(caption,"Its center is (1/4, 0) and its radius is 1/4, so the origin lies exactly on the boundary.",0.60,smooth);
+}
+wait(0.95);
+step("solve") { par { pulse(image,0.75); say(head,"A straight line becomes a circle.",0.4,smooth); } }
+wait(1.25);
+step("cta") { par { fade(kicker,0.3); fade(head,0.3); fade(caption,0.3); fade(eq,0.3); fade(unit,0.3); fade(O,0.3); fade(image,0.35); fade(me.footer,0.3); show(me.endcard,0.6); } }
+wait(2.2);

package/examples/creator-lsystem-fractal-curve.manic

@@ -0,0 +1,121 @@
+// Creator story: one seven-segment rewriting rule grows from a square into a
+// 9,604-segment space-filling curve. The rule is the story—not implementation.
+
+title("How One Line Learns to Fill Space");
+canvas("9:16");
+template("mono");
+
+creator(me, "@anish2good name=Manic_Geometry tagline=Rules_made_visible yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=cyan secondary=magenta footer=compact cta=Animate_your_idea safe=clean");
+socials(me);
+watermark(manicMark, (w*0.15, h*0.06), "Made With Manic");
+endcard(me, "title=Turn_Rules_Into_Stories cta=8gwifi.org/manic");
+
+let u = (w+h-abs(w-h))/1080;
+text(kicker, (cx, h*0.14), "MANIC · GENERATIVE GEOMETRY");
+text(headline, (cx, h*0.24), "One rule. 9,604 lines.");
+text(caption, (cx, h*0.79), "Start with a square.");
+text(generation, (cx, h*0.69), "GENERATION 0 · 4 SEGMENTS");
+text(rule, (cx, h*0.30), "F  →  FF + F + F + F + FF");
+size(kicker, 20*u); bold(kicker); color(kicker, cyan);
+size(headline, 30*u); bold(headline); wrap(headline, w*0.78);
+size(caption, 23*u); bold(caption); wrap(caption, w*0.74);
+size(generation, 20*u); bold(generation); color(generation, dim);
+size(rule, 25*u); bold(rule); color(rule, gold);
+
+let stageSize = (w+h-abs(w-h))*0.28;
+let stageY = h*0.49;
+
+lsystem(curve, (cx, stageY), stageSize,
+  "F+F+F+F", "F=FF+F+F+F+FF",
+  "angle=90 iterations=0");
+color(curve, cyan); stroke(curve, 5);
+
+lsystem(gen1, (cx, stageY), stageSize,
+  "F+F+F+F", "F=FF+F+F+F+FF",
+  "angle=90 iterations=1");
+color(gen1, cyan); stroke(gen1, 4); hidden(gen1);
+
+lsystem(gen2, (cx, stageY), stageSize,
+  "F+F+F+F", "F=FF+F+F+F+FF",
+  "angle=90 iterations=2");
+color(gen2, cyan); stroke(gen2, 3.5); hidden(gen2);
+
+lsystem(gen3, (cx, stageY), stageSize,
+  "F+F+F+F", "F=FF+F+F+F+FF",
+  "angle=90 iterations=3");
+color(gen3, magenta); stroke(gen3, 3); hidden(gen3);
+
+lsystem(finalCurve, (cx, stageY), stageSize,
+  "F+F+F+F", "F=FF+F+F+F+FF",
+  "angle=90 iterations=4");
+gradient(finalCurve, cyan, magenta, gold);
+stroke(finalCurve, 2.2); untraced(finalCurve); hidden(finalCurve);
+
+hidden(kicker); hidden(headline); hidden(rule);
+
+step("ask the impossible question") {
+  seq {
+    par {
+      show(kicker, 0.35);
+      show(headline, 0.50);
+      show(rule, 0.50);
+      show(curve, 0.40);
+    }
+    pulse(curve, 0.60);
+  }
+}
+wait(0.45);
+
+step("rewrite every forward move") {
+  seq {
+    say(caption, "Replace every F with seven smaller forward moves.", 0.45, smooth);
+    par {
+      become(curve, gen1, 0.85, smooth);
+      say(generation, "GENERATION 1 · 28 SEGMENTS", 0.35, smooth);
+    }
+    par {
+      become(curve, gen2, 0.95, smooth);
+      say(generation, "GENERATION 2 · 196 SEGMENTS", 0.35, smooth);
+    }
+    par {
+      become(curve, gen3, 1.05, smooth);
+      say(generation, "GENERATION 3 · 1,372 SEGMENTS", 0.35, smooth);
+    }
+  }
+}
+wait(0.50);
+
+step("let the path fill space") {
+  seq {
+    par {
+      fade(curve, 0.35);
+      say(caption, "Repeat once more. The same rule now draws 9,604 connected segments.", 0.45, smooth);
+      say(generation, "GENERATION 4 · 9,604 SEGMENTS", 0.35, smooth);
+    }
+    show(finalCurve, 0.05);
+    draw(finalCurve, 3.20, smooth);
+    pulse(finalCurve, 0.80);
+  }
+}
+wait(0.75);
+
+step("the idea is the animation") {
+  seq {
+    say(caption, "In Manic, creators describe the rule. The engine makes it move.", 0.45, smooth);
+    par {
+      recolor(headline, gold, 0.50);
+      pulse(finalCurve, 0.85);
+    }
+  }
+}
+wait(1.00);
+
+step("creator call to action") {
+  par {
+    fade(kicker, 0.35); fade(headline, 0.35); fade(rule, 0.35);
+    fade(caption, 0.35); fade(generation, 0.35); fade(finalCurve, 0.45);
+    fade(me.footer, 0.35);
+    show(me.endcard, 0.60);
+  }
+}
+wait(1.80);

package/examples/creator-mandelbrot-escape-test.manic

@@ -0,0 +1,58 @@
+// Existing-Manic treatment of fractales/fig0080.asy.
+// Instead of a raster, solve the defining membership test for c=1.
+
+title("A Mandelbrot Escape Test");
+canvas("9:16");
+template("black");
+creator(me,"@anish2good name=Manic_Math tagline=Complexity_made_visible yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=magenta secondary=cyan footer=compact cta=Test_another_point safe=clean");
+socials(me);
+watermark(mark,(w*0.16,h*0.055),"Made With Manic");
+endcard(me,"title=Animate_The_Definition cta=8gwifi.org/manic");
+
+let u=(w+h-abs(w-h))/1080;
+text(kicker,(cx,h*0.10),"MANDELBROT · ESCAPE TEST");
+text(head,(cx,h*0.17),"Does c = 1 belong?");
+equation(rule,(cx,h*0.25),`z_{n+1}=z_n^2+c,\qquad z_0=0`,31*u);
+text(caption,(cx,h*0.76),"A point belongs only if its orbit stays bounded forever.");
+size(kicker,20*u); bold(kicker); color(kicker,magenta);
+size(head,28*u); bold(head); wrap(head,w*0.76);
+size(caption,20*u); bold(caption); wrap(caption,w*0.74); color(caption,dim);
+
+line(axis,(w*0.14,h*0.51),(w*0.86,h*0.51)); color(axis,dim);
+dot(z0,(w*0.20,h*0.51),10*u); dot(z1,(w*0.34,h*0.51),10*u);
+dot(z2,(w*0.48,h*0.51),10*u); dot(z3,(w*0.78,h*0.51),12*u);
+text(l0,(w*0.20,h*0.56),"0"); text(l1,(w*0.34,h*0.56),"1");
+text(l2,(w*0.48,h*0.56),"2"); text(l3,(w*0.78,h*0.56),"5");
+tag(z0,orbit); tag(z1,orbit); tag(z2,orbit); tag(z3,orbit);
+tag(l0,orbit); tag(l1,orbit); tag(l2,orbit); tag(l3,orbit);
+color(z0,cyan); color(z1,cyan); color(z2,gold); color(z3,magenta);
+hidden(orbit); untraced(axis); hidden(kicker); hidden(head); hidden(rule); hidden(caption);
+
+step("state the problem") { par { show(kicker,0.3); show(head,0.4); show(rule,0.5); show(caption,0.35); draw(axis,0.65,smooth); } }
+wait(0.85);
+step("iterate") {
+  seq {
+    par { show(z0,0.2); show(l0,0.2); say(caption,"Start at zero.",0.3); }
+    par { show(z1,0.25); show(l1,0.25); say(caption,"z₁ = 0² + 1 = 1",0.3); }
+    par { show(z2,0.25); show(l2,0.25); say(caption,"z₂ = 1² + 1 = 2",0.3); }
+    par { show(z3,0.3); show(l3,0.3); say(caption,"z₃ = 2² + 1 = 5. The orbit has escaped beyond radius 2.",0.4); }
+  }
+}
+wait(0.9);
+step("apply the escape rule") {
+  par {
+    pulse(z3,0.80);
+    say(caption,"Once |z| exceeds 2, repeated squaring can never bring this orbit back to a bounded region.",0.60,smooth);
+  }
+}
+wait(1.0);
+step("interpret the test") {
+  say(rule,"One escaped orbit is enough to reject the point c = 1.",0.60,smooth);
+}
+wait(0.9);
+step("answer") {
+  par { say(head,"No — c = 1 escapes.",0.45,smooth); rewrite(rule,`0\to1\to2\to5\to26\to\cdots`,0.8,smooth); pulse(z3,0.7); }
+}
+wait(1.3);
+step("cta") { par { fade(kicker,0.3); fade(head,0.3); fade(rule,0.3); fade(caption,0.3); fade(axis,0.3); fade(orbit,0.35); fade(me.footer,0.3); show(me.endcard,0.6); } }
+wait(2.2);

package/examples/creator-monty-hall.manic

@@ -0,0 +1,104 @@
+// creator-monty-hall.manic — a Creator v2 Short on the Monty Hall problem, one of
+// the most-searched (and most-argued) puzzles in probability, narrated with an
+// ElevenLabs voice story. The whole cast is imported SVG — three door emoji, a car,
+// goats, a party popper — and the teaching beat is visual: when the host opens a
+// goat door, its 1/3 chance visibly SLIDES onto the other door, making it 2/3. The
+// payoff `morph`s a goat into the car with a confetti `burst`. Problem → the
+// counter-intuitive solution → CTA, 9:16 shorts template, branded.
+//
+//   ELEVENLABS_API_KEY=... manic examples/creator-monty-hall.manic --record out.mp4
+//   speak("…") = voice only;  say(cap,"…") = on-screen caption.
+title("The Monty Hall Problem");
+canvas("9:16");
+template("shorts");
+voice("elevenlabs");
+
+creator(me, "@anish2good name=Manic tagline=Turn_plain_text_into_amazing_math_videos yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=cyan secondary=magenta footer=signature cta=Try_it_free safe=reels");
+watermark(manicMark, (w*0.955-100, h*0.045+24), "Made With Manic");
+
+// --- header ---
+text(kick, (cx, h*0.10), "The Monty Hall Problem"); size(kick, 48); color(kick, fg); bold(kick); wrap(kick, w*0.86); hidden(kick);
+text(sub, (cx, h*0.155), "The puzzle that fooled even the pros"); size(sub, 29); color(sub, dim); wrap(sub, w*0.82); hidden(sub);
+
+// --- three doors (imported emoji), numbered, with a 1/3 odds chip each ---
+let dy = h*0.375;
+let dsz = w*0.185;
+let xL = w*0.22; let xM = w*0.50; let xR = w*0.78;
+svg(door1, (xL, dy), "asset:svg/emoji/door.svg", dsz); hidden(door1);
+svg(door2, (xM, dy), "asset:svg/emoji/door.svg", dsz); hidden(door2);
+svg(door3, (xR, dy), "asset:svg/emoji/door.svg", dsz); hidden(door3);
+text(t1, (xL, dy-dsz*0.66), "1"); size(t1, 32); color(t1, dim); bold(t1); hidden(t1);
+text(t2, (xM, dy-dsz*0.66), "2"); size(t2, 32); color(t2, dim); bold(t2); hidden(t2);
+text(t3, (xR, dy-dsz*0.66), "3"); size(t3, 32); color(t3, dim); bold(t3); hidden(t3);
+counter(chip1, (xL, dy+dsz*1.02), 33, 0, "", "%"); size(chip1, 44); color(chip1, dim); bold(chip1); hidden(chip1);
+counter(chip2, (xM, dy+dsz*1.02), 33, 0, "", "%"); size(chip2, 44); color(chip2, dim); bold(chip2); hidden(chip2);
+counter(chip3, (xR, dy+dsz*1.02), 33, 0, "", "%"); size(chip3, 44); color(chip3, dim); bold(chip3); hidden(chip3);
+
+// a selection ring for "your pick"
+circle(pick, (xL, dy), dsz*0.62); outlined(pick); outline(pick, cyan); stroke(pick, 5); glow(pick, 0.8); hidden(pick);
+
+// prizes hidden BEHIND each door (revealed when a door lifts)
+svg(goat1, (xL, dy), "asset:svg/emoji/goat.svg", dsz*0.86); z(goat1, -1); hidden(goat1);
+svg(goat3, (xR, dy), "asset:svg/emoji/goat.svg", dsz*0.86); z(goat3, -1); hidden(goat3);
+// behind door 2: a goat that MORPHS into the car (the payoff flourish)
+svg(goatH, (xM, dy), "asset:svg/emoji/goat.svg", dsz*0.92); z(goatH, -1); hidden(goatH);
+svg(carH,  (xM, dy), "asset:svg/emoji/car.svg",  dsz*1.02); z(carH, -1); hidden(carH);
+morph(goatH, carH);
+svg(party, (xM+dsz*0.9, dy-dsz*0.8), "asset:svg/emoji/party.svg", dsz*0.7); z(party, 6); hidden(party);
+circle(bcore, (xM, dy), 30); hidden(bcore);
+particles(sparks, bcore, 26, 8, 11, "random"); color(sparks, gold); glow(sparks, 0.9); z(sparks, 7); hidden(sparks);
+
+// one caption line, retexted through the story
+text(cap, (cx, h*0.66), ""); size(cap, 35); color(cap, dim); bold(cap); wrap(cap, w*0.86); hidden(cap);
+
+socials(me);
+endcard(me, "title=Always_Switch cta=8gwifi.org/manic");
+
+// ---------------- the story (voice leads; visuals punctuate) ----------------
+par { show(kick); show(sub); }
+stagger(0.16) { show(door1); show(door2); show(door3); }
+par { show(t1); show(t2); show(t3); show(chip1); show(chip2); show(chip3); }
+show(cap, 0.3); say(cap, "1 car, 2 goats — 1/3 each.");
+speak("Three doors. One car, two goats. You pick door one.");
+par { show(pick); pulse(door1); }
+say(cap, "You pick Door 1.");
+
+speak("Now the host, who knows, opens door three. A goat.");
+recolor(cap, dim); say(cap, "Host opens Door 3 — a goat.");
+show(goat3);
+par { move(door3, (xR, dy-h*0.30), 0.7, smooth); fade(door3); }
+
+speak("The twist: door three's odds don't vanish. They slide onto door two.");
+recolor(cap, cyan); say(cap, "Its 1/3 slides to Door 2.");
+par { move(chip3, (xM, dy+dsz*1.02), 0.8, smooth); fade(chip3); to(chip2, value, 67, 0.8); }
+par { recolor(chip2, cyan); recolor(chip1, magenta); }
+
+speak("Most people say fifty-fifty. It isn't.");
+recolor(cap, red); say(cap, "Feels like 50/50. It's not."); shake(cap);
+
+speak("Your door stays one-in-three. Door two? Two-in-three. Switching doubles it.");
+recolor(cap, gold); say(cap, "STAY 33%   ·   SWITCH 67%");
+par { pulse(chip2); pulse(door2); }
+
+speak("So you switch...");
+recolor(cap, dim); say(cap, "So you switch…");
+show(goatH);
+par { move(door2, (xM, dy-h*0.30), 0.7, smooth); fade(door2); fade(chip1); fade(chip2); }
+
+speak("...and the goat becomes a car.");
+to(goatH, morph, 1, 0.9, smooth);
+par { fade(goatH); show(carH); }
+recolor(cap, gold); say(cap, "…and win the car!");
+par { show(sparks, 0.05); burst(sparks, 1.1); show(party); pulse(carH); }
+wait(0.6);
+
+speak("Door one? A goat. Switching wins two out of three.");
+recolor(cap, dim); say(cap, "Door 1 was a goat.");
+show(goat1);
+par { move(door1, (xL, dy-h*0.30), 0.7, smooth); fade(door1); fade(pick); fade(party); }
+wait(0.4);
+
+speak("Always switch. One Manic script made this — turn any idea into a video at eight g wifi dot org slash manic.");
+par { fade(kick); fade(sub); fade(cap); fade(carH); fade(goat1); fade(goat3); fade(t1); fade(t2); fade(t3); fade(chip3); }
+show(me.endcard);
+wait(2.6);

package/examples/creator-noise-story.manic

@@ -0,0 +1,123 @@
+// How Noise Builds Worlds — a Creator v2 Short on procedural noise, 1D → 2D → 3D →
+// fractal. Raw RANDOM values (jagged) vs smooth PERLIN noise(x); then noise(x,y) as
+// a surface; then stacking octaves (fbm) for fractal detail. Every visual is one
+// formula — `rand`, `noise`, `fbm`. Captions use the word-pop (karaoke) variant;
+// the final scene pulls the camera back for a full view of the fractal world.
+title("How Noise Builds Worlds");
+canvas("9:16");
+template("shorts");
+
+creator(me, "@anish2good name=Manic tagline=Turn_plain_text_into_amazing_math_videos yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=cyan secondary=magenta footer=signature cta=Try_it_free safe=reels");
+watermark(mk, (w*0.955-100, h*0.045+24), "Made With Manic");
+
+// --- 1D: a coordinate frame with two curves, raw random vs smooth noise ---
+axes(ax, (cx, h*0.33), w*0.4, 150);
+color(ax, dim); untraced(ax);
+plot(rnd, (cx, h*0.33), 62, 130, "rand(x)", (-6.5, 6.5));
+color(rnd, magenta); untraced(rnd);
+plot(perlin, (cx, h*0.33), 62, 130, "noise(x, 0)", (-6.5, 6.5));
+color(perlin, cyan); glow(perlin, 0.7); untraced(perlin);
+
+// --- 2D/3D: the same idea one dimension up. Near top-down so it reads flat first. ---
+camera3((0, -1.5, 20), (0, 0, 0), 24);
+surface3(hills, "noise(x*0.9, y*0.9)*2.0", (-4, 4), (-4, 4), 50);
+color(hills, cyan); hidden(hills);
+surface3(frac, "fbm(x*0.95, y*0.95)*2.4", (-4, 4), (-4, 4), 72);
+color(frac, cyan); hidden(frac);
+
+text(kicker, (cx, h*0.135), "random is not the same as noise");
+size(kicker, 32); color(kicker, cyan); bold(kicker); wrap(kicker, w*0.82);
+untraced(kicker); cursor(kicker);
+
+// Word-pop captions — one per beat, popped in a word at a time, faded before the next.
+caption(cR, "raw random values", (cx, h*0.75), 33, magenta); hidden(cR.words);
+caption(cP, "smooth it into noise", (cx, h*0.75), 33, cyan); hidden(cP.words);
+caption(cD, "add a dimension", (cx, h*0.75), 33, dim); hidden(cD.words);
+caption(cL, "values become heights", (cx, h*0.75), 33, dim); hidden(cL.words);
+caption(cF, "octaves build fractals", (cx, h*0.75), 33, cyan); hidden(cF.words);
+caption(cE, "1D  2D  3D  fractal", (cx, h*0.75), 34, cyan); hidden(cE.words);
+caption(cM, "one formula. That's Manic.", (cx, h*0.75), 32, cyan); hidden(cM.words);
+
+socials(me);
+endcard(me, "title=Try_Manic cta=8gwifi.org/manic");
+
+// 1 — HOOK + raw random values (jagged).
+mark("hook");
+type(kicker, 1.3);
+step("random") {
+  par {
+    draw(ax, 0.6);
+    draw(rnd, 1.3);
+    seq { wait(0.5); wordpop(cR, 0.14); }
+  }
+}
+wait(0.5);
+
+// 2 — smooth it into Perlin noise(x).
+step("perlin") {
+  par {
+    fade(cR.words, 0.3);
+    fade(rnd, 0.5);
+    draw(perlin, 1.4);
+    seq { wait(0.4); wordpop(cP, 0.13); }
+  }
+}
+wait(0.6);
+
+// 3 — one dimension up: noise(x,y) as a field (top-down reads flat).
+step("to2d") {
+  par {
+    fade(cP.words, 0.3);
+    fade(ax, 0.5); fade(perlin, 0.5);
+    show(hills, 0.7);
+    seq { wait(0.4); wordpop(cD, 0.14); }
+  }
+}
+
+// 4 — tilt: the field IS a 3D surface (a heightmap).
+step("lift") {
+  par {
+    fade(cD.words, 0.3);
+    orbit3(25, 34, 16, 3.6, smooth);
+    seq { wait(0.5); wordpop(cL, 0.13); }
+  }
+}
+wait(0.5);
+
+// 5 — stack octaves into fbm; pull the camera WAY back for the full world.
+step("fbm") {
+  par {
+    fade(cL.words, 0.3);
+    fade(hills, 0.6);
+    show(frac, 0.7);
+    orbit3(120, 40, 30, 3.4, smooth);
+    seq { wait(0.5); wordpop(cF, 0.13); }
+  }
+}
+
+// 6 — a slow tour of the whole fractal world at full distance.
+step("tour") {
+  par {
+    fade(cF.words, 0.3);
+    orbit3(240, 36, 30, 4.6, smooth);
+    seq { wait(0.4); wordpop(cE, 0.16); }
+  }
+}
+wait(0.4);
+
+// 7 — THE POINT.
+step("point") {
+  seq {
+    fade(cE.words, 0.3);
+    wordpop(cM, 0.16);
+  }
+}
+wait(1.1);
+
+// 8 — END CARD.
+mark("endcard");
+par {
+  fade(kicker, 0.4); fade(cM.words, 0.4); fade(me.footer, 0.4); fade(frac, 0.5);
+}
+show(me.endcard, 0.6);
+wait(1.6);