@maniclang/workbench 0.1.11

package/examples/trajectory.manic

@@ -0,0 +1,28 @@
+title("Phase portrait: flowing into a spiral sink");
+canvas("16:9");
+
+text(hdr, (cx, 60), "dx/dt = -y - 0.2x,   dy/dt = x - 0.2y");
+size(hdr, 26); color(hdr, cyan); bold(hdr); display(hdr); hidden(hdr);
+
+// a reference frame centered on the sink
+axes(ax, (cx, cy + 20), 620, 360, 1);
+color(ax, dim); untraced(ax);
+
+// three trajectories from different starts, each spiraling into the origin
+trajectory(t1, "-y - 0.2*x", "x - 0.2*y", (3.2, 0), (cx, cy + 20), 110, 520);
+color(t1, cyan); stroke(t1, 3); untraced(t1);
+
+trajectory(t2, "-y - 0.2*x", "x - 0.2*y", (0, 3.4), (cx, cy + 20), 110, 520);
+color(t2, magenta); stroke(t2, 3); untraced(t2);
+
+trajectory(t3, "-y - 0.2*x", "x - 0.2*y", (-3.0, -2.4), (cx, cy + 20), 110, 520);
+color(t3, gold); stroke(t3, 3); untraced(t3);
+
+// ---- timeline ----
+show(hdr, 0.5);
+draw(ax, 0.8);
+par {
+  draw(t1, 3.5);
+  draw(t2, 3.5);
+  draw(t3, 3.5);
+}

package/examples/transform_copy.manic

@@ -0,0 +1,35 @@
+// Copy + Winding Morph — two of the Transform family niceties. `copy(c, a)`
+// duplicates a shape so the original stays while the copy transforms; `morph`
+// with a spin angle winds the blend (Manim's Clockwise / Counterclockwise
+// Transform). Left copy morphs clockwise, right copy counter-clockwise.
+//
+//   manic examples/transform_copy.manic
+
+title("Copy + Winding Morph");
+canvas("16:9");
+
+text(head, (cx, 96), "a copy morphs while the original stays -- one CW, one CCW");
+color(head, cyan);  size(head, 23);  hidden(head);
+
+// left: original circle (dim) + a cyan copy that morphs into a square, clockwise
+circle(o1, (400, 380), 120);  color(o1, dim);  stroke(o1, 3);  hidden(o1);
+rect(t1, (400, 380), 220, 220);  hidden(t1);
+copy(c1, o1);  color(c1, cyan);  stroke(c1, 5);  glow(c1, 1.6);  hidden(c1);
+morph(c1, t1, 200);          // +200 deg = clockwise wind
+
+// right: same idea, counter-clockwise into a triangle-ish (use another square)
+circle(o2, (900, 380), 120);  color(o2, dim);  stroke(o2, 3);  hidden(o2);
+rect(t2, (900, 380), 220, 220);  hidden(t2);
+copy(c2, o2);  color(c2, magenta);  stroke(c2, 5);  glow(c2, 1.6);  hidden(c2);
+morph(c2, t2, -200);         // -200 deg = counter-clockwise
+
+// --- script ---
+show(head, 0.5);
+par { show(o1, 0.4);  show(o2, 0.4);  show(c1, 0.4);  show(c2, 0.4); }
+wait(0.5);
+
+section("Morph the copies");
+par { to(c1, morph, 1, 1.8, smooth);  to(c2, morph, 1, 1.8, smooth); }
+wait(0.9);
+par { to(c1, morph, 0, 1.8, smooth);  to(c2, morph, 0, 1.8, smooth); }
+wait(1.2);

package/examples/transforms.manic

@@ -0,0 +1,54 @@
+// Transforms — the "animate anything" showcase.
+// Named verbs (rotate, spin, scale, move) plus the general `to(id, prop, value)`
+// escape hatch, composed with par / seq / stagger.
+//
+//   manic examples/transforms.manic
+//   manic examples/transforms.manic --record out --fps 60 --crt
+
+title("Transforms");
+canvas(1280, 720);
+
+// cast
+rect(box, (330, 400), 150, 150);   outline(box, cyan);
+label(box, "rotate");
+rect(dia, (650, 400), 140, 140);   outline(dia, magenta);
+label(dia, "to");
+circle(orb, (980, 400), 62);       outline(orb, lime);
+label(orb, "spin");
+
+dot(p, (150, 620), 12);
+text(cap, (640, 662), "");  color(cap, dim);  size(cap, 22);
+text(head, (640, 120), "animate anything");
+display(head);  color(head, cyan);  size(head, 40);  hidden(head);
+
+// script
+show(head, 0.5);
+
+section("Named verbs");
+say(cap, "rotate to an absolute angle");
+rotate(box, 45, 0.7, overshoot);
+say(cap, "spin by a relative angle, twice");
+seq {
+  spin(orb, 180, 0.6);
+  spin(orb, 180, 0.6);
+}
+wait(0.4);
+
+section("Animate anything");
+say(cap, "to(id, property, value) reaches any property");
+par {
+  to(dia, angle, 45, 0.6, smooth);
+  to(dia, scale, 1.4, 0.6);
+  to(dia, color, lime, 0.6);
+}
+wait(0.4);
+
+say(cap, "compose freely with par / seq / stagger");
+stagger(0.12) {
+  to(box, opacity, 0.4, 0.4);
+  to(dia, opacity, 0.4, 0.4);
+  to(orb, opacity, 0.4, 0.4);
+}
+to(p, x, 1130, 1.0, overshoot);
+to(p, color, magenta, 0.4);
+wait(1.0);

package/examples/trapped-light-dimensions.manic

@@ -0,0 +1,226 @@
+// ============================================================================
+// trapped-light-dimensions.manic — a continuous 1D → 2D → 3D journey
+// ----------------------------------------------------------------------------
+// One photon and one equation persist through the whole story. A fiber sweeps
+// sideways into a glass floor; that same floor rises into a transparent room.
+// The visual construction makes the distance formula grow one perpendicular
+// square at a time instead of presenting three unrelated formulas.
+// ============================================================================
+
+title("The Trapped Light Beam — From 1D to 3D");
+canvas("9:16");
+template("neon");
+watermark(manicMark, (238, 108), "Made With Manic");
+
+creator(me, "@anish2good name=Manic_3D tagline=Build_dimensions_visually yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=cyan secondary=magenta footer=social safe=reels");
+socials(me);
+
+text(kicker, (540, 164), "A JOURNEY THROUGH DIMENSIONS");
+size(kicker, 21); bold(kicker); color(kicker, cyan); hidden(kicker);
+text(headline, (540, 228), "The trapped light beam");
+size(headline, 43); bold(headline); color(headline, fg); hidden(headline);
+text(dimension, (540, 300), "1D · A THREAD IN THE DARK");
+size(dimension, 23); bold(dimension); color(dimension, gold); hidden(dimension);
+
+text(narration, (540, 1328), "No up. No down. Only backwards and forwards.");
+size(narration, 27); bold(narration); color(narration, fg); wrap(narration, 860); hidden(narration);
+text(insight, (540, 1386), "One permitted direction");
+size(insight, 20); color(insight, dim); hidden(insight);
+
+equation(distance, (540, 1482), `L=\left|x_2-x_1\right|`, 39);
+hidden(distance);
+
+// ---------------------------------------------------------------------------
+// THE SPATIAL CAST
+// ---------------------------------------------------------------------------
+
+camera3((9, -16, 8), (2.5, 0, 0), 38);
+
+// 1D: a five-unit fiber and one persistent photon.
+line3(fiber, (0,0,0), (5,0,0)); color(fiber, cyan); thick(fiber, 0.065); untraced(fiber);
+point3(A, (0,0,0), 0.16); color(A, fg); hidden(A);
+point3(B, (5,0,0), 0.16); color(B, fg); hidden(B);
+point3(photon, (0,0,0), 0.22); color(photon, gold); hidden(photon);
+finish3(photon, "material=glass shading=smooth depth=0.35 shadow=0.20");
+
+text(aLabel, (0,0), "A · x = 0"); size(aLabel, 21); color(aLabel, fg); hidden(aLabel); pin3(aLabel, A);
+text(bLabel, (0,0), "B · x = 5"); size(bLabel, 21); color(bLabel, fg); hidden(bLabel); pin3(bLabel, B);
+point3(xMid, (2.5,0,0), 0.01); hidden(xMid);
+text(xLabel, (0,0), "a = 5"); size(xLabel, 22); bold(xLabel); color(xLabel, cyan); hidden(xLabel); pin3(xLabel, xMid);
+
+// 2D: pull a copy of the fiber along y. The shallow cuboid is the glass floor.
+line3(sweepLine, (0,0,0), (5,0,0)); color(sweepLine, magenta); thick(sweepLine, 0.045); hidden(sweepLine);
+line3(yEdge, (0,0,0), (0,12,0)); color(yEdge, magenta); thick(yEdge, 0.045); untraced(yEdge); hidden(yEdge);
+point3(yMid, (0,6,0), 0.01); hidden(yMid);
+text(yLabel, (0,0), "b = 12"); size(yLabel, 22); bold(yLabel); color(yLabel, magenta); hidden(yLabel); pin3(yLabel, yMid);
+
+cube3(glassFloor, (2.5,6,0), (5,12,0.12)); color(glassFloor, blue); hidden(glassFloor);
+finish3(glassFloor, "material=glass shading=flat mesh=0.42 depth=0.30 shadow=0.12");
+line3(floorDiagonal, (0,0,0.08), (5,12,0.08)); color(floorDiagonal, gold); thick(floorDiagonal, 0.075); untraced(floorDiagonal); hidden(floorDiagonal);
+point3(floorTarget, (5,12,0.08), 0.19); color(floorTarget, fg); hidden(floorTarget);
+text(floorTargetLabel, (0,0), "(5, 12)"); size(floorTargetLabel, 20); color(floorTargetLabel, fg); hidden(floorTargetLabel); pin3(floorTargetLabel, floorTarget);
+point3(floorMid, (2.5,6,0.08), 0.01); hidden(floorMid);
+text(floorPathLabel, (0,0), "base = 13"); size(floorPathLabel, 21); bold(floorPathLabel); color(floorPathLabel, gold); hidden(floorPathLabel); pin3(floorPathLabel, floorMid);
+
+// 3D: the flat floor becomes a transparent room. The 84-unit height is
+// compressed to 18 visual units so the reused 13-unit floor diagonal remains
+// readable; labels and mathematics retain the real coordinates. Four persistent
+// roof edges rise as one tagged rig while the transparent volume resolves.
+cube3(room, (2.5,6,9), (5,12,18)); color(room, blue); hidden(room);
+finish3(room, "material=glass shading=flat mesh=0.50 depth=0.38 shadow=0.16");
+line3(roofFront, (0,0,0), (5,0,0)); color(roofFront, cyan); thick(roofFront, 0.055); hidden(roofFront); tag(roofFront, roof);
+line3(roofBack, (0,12,0), (5,12,0)); color(roofBack, cyan); thick(roofBack, 0.055); hidden(roofBack); tag(roofBack, roof);
+line3(roofLeft, (0,0,0), (0,12,0)); color(roofLeft, cyan); thick(roofLeft, 0.055); hidden(roofLeft); tag(roofLeft, roof);
+line3(roofRight, (5,0,0), (5,12,0)); color(roofRight, cyan); thick(roofRight, 0.055); hidden(roofRight); tag(roofRight, roof);
+line3(zEdge, (5,12,0), (5,12,18)); color(zEdge, lime); thick(zEdge, 0.08); untraced(zEdge); hidden(zEdge);
+point3(zMid, (5,12,9), 0.01); hidden(zMid);
+text(zLabel, (0,0), "c = 84"); size(zLabel, 22); bold(zLabel); color(zLabel, lime); hidden(zLabel); pin3(zLabel, zMid);
+
+line3(spaceDiagonal, (0,0,0), (5,12,18)); color(spaceDiagonal, gold); thick(spaceDiagonal, 0.10); untraced(spaceDiagonal); hidden(spaceDiagonal);
+point3(spaceTarget, (5,12,18), 0.24); color(spaceTarget, fg); hidden(spaceTarget);
+text(spaceTargetLabel, (0,0), "(5, 12, 84)"); size(spaceTargetLabel, 20); color(spaceTargetLabel, fg); hidden(spaceTargetLabel); pin3(spaceTargetLabel, spaceTarget);
+
+// ---------------------------------------------------------------------------
+// THE JOURNEY
+// ---------------------------------------------------------------------------
+
+step("one dimension") {
+  seq {
+    par {
+      show(kicker, 0.35);
+      show(headline, 0.55);
+      show(dimension, 0.40);
+      show(narration, 0.45);
+      show(insight, 0.45);
+      show(distance, 0.55);
+      view3(fiber, "front", 1.0, smooth, 1.65);
+    }
+    stagger(0.12) {
+      show(A, 0.30);
+      show(aLabel, 0.30);
+      draw(fiber, 1.10, smooth);
+      show(B, 0.30);
+      show(bLabel, 0.30);
+      show(xLabel, 0.30);
+      show(photon, 0.35);
+    }
+    wait(0.45);
+  }
+}
+
+step("the bound beam") {
+  seq {
+    say(narration, "Fire one photon from A to B. There is nowhere else to go.", 0.50, smooth);
+    par {
+      travel3(photon, fiber, 2.25, smooth);
+      rewrite(distance, `L=\left|5-0\right|=\textcolor{gold}{5}`, 1.10, smooth);
+      say(insight, "Distance is the length of the only available track", 0.45, smooth);
+    }
+    pulse(photon, 0.70);
+    wait(0.55);
+  }
+}
+
+step("unlock the second direction") {
+  seq {
+    par {
+      move3(photon, (0,0,0), 0.80, smooth);
+      fade(aLabel, 0.35);
+      fade(bLabel, 0.35);
+      say(dimension, "2D · UNFOLDING THE FLOOR", 0.45, smooth);
+      say(narration, "Pull the fiber sideways. One line sweeps out a reflective surface.", 0.55, smooth);
+      say(insight, "A new perpendicular direction appears: y", 0.45, smooth);
+    }
+    par {
+      show(yEdge, 0.15);
+      draw(yEdge, 1.10, smooth);
+      show(yLabel, 0.35);
+      view3(glassFloor, "isometric", 1.35, smooth, 1.55);
+    }
+    par {
+      show(sweepLine, 0.25);
+      move3(sweepLine, (0,12,0), 1.90, smooth);
+      show(glassFloor, 1.90, smooth);
+    }
+    to(glassFloor, opacity, 0.22, 0.40, smooth);
+    wait(0.45);
+  }
+}
+
+step("cut across the floor") {
+  seq {
+    par {
+      show(floorTarget, 0.30);
+      show(floorTargetLabel, 0.35);
+      show(floorPathLabel, 0.35);
+      say(narration, "The photon can turn now — but the straight diagonal is shortest.", 0.55, smooth);
+      say(insight, "The old distance and the new sweep meet at 90 degrees", 0.45, smooth);
+    }
+    par {
+      show(floorDiagonal, 0.15);
+      draw(floorDiagonal, 2.35, smooth);
+      travel3(photon, floorDiagonal, 2.35, smooth);
+      rewrite(distance, `L=\sqrt{\textcolor{cyan}{5^2}+\textcolor{magenta}{12^2}}=\sqrt{169}=\textcolor{gold}{13}`, 1.35, smooth);
+    }
+    pulse(photon, 0.70);
+    wait(0.65);
+  }
+}
+
+step("raise the roof") {
+  seq {
+    par {
+      move3(photon, (0,0,0), 0.90, smooth);
+      fade(xLabel, 0.35);
+      fade(yLabel, 0.35);
+      fade(floorTargetLabel, 0.35);
+      say(dimension, "3D · FILLING THE VOID", 0.45, smooth);
+      say(narration, "Lift the entire floor upward. Surface becomes volume.", 0.55, smooth);
+      say(insight, "Height compressed visually · coordinates and geometry stay exact", 0.45, smooth);
+    }
+    par {
+      to(room, opacity, 0.22, 2.45, smooth);
+      show(roof, 0.20);
+      shift3(roof, (0,0,18), 2.45, smooth);
+      view3(room, "isometric", 2.45, smooth, 1.62);
+      show(zEdge, 0.15);
+      draw(zEdge, 2.30, smooth);
+      show(zLabel, 0.45);
+    }
+    par { show(spaceTarget, 0.40); show(spaceTargetLabel, 0.40); }
+    wait(0.55);
+  }
+}
+
+step("cut through space") {
+  seq {
+    say(narration, "The photon cuts through open space: floor diagonal against height.", 0.55, smooth);
+    par {
+      show(spaceDiagonal, 0.15);
+      draw(spaceDiagonal, 2.80, smooth);
+      travel3(photon, spaceDiagonal, 2.80, smooth);
+      rewrite(distance, `L=\sqrt{\textcolor{gold}{13^2}+\textcolor{lime}{84^2}}=\sqrt{7225}=\textcolor{gold}{85}`, 1.50, smooth);
+      say(insight, "13² + 84² = 85²", 0.45, smooth);
+    }
+    pulse(photon, 0.80);
+    wait(0.70);
+  }
+}
+
+step("one recursive idea") {
+  seq {
+    par {
+      say(dimension, "THE PATTERN · ONE RIGHT ANGLE AT A TIME", 0.50, smooth);
+      say(narration, "Do not memorize three formulas. Build one distance recursively.", 0.55, smooth);
+      say(insight, "Each previous diagonal becomes the next dimension's base", 0.50, smooth);
+      rewrite(distance, `L=\sqrt{\textcolor{cyan}{a^2}+\textcolor{magenta}{b^2}+\textcolor{lime}{c^2}}`, 1.65, smooth);
+      view3(room, "fit", 2.20, smooth, 1.70);
+    }
+    par {
+      pulse(photon, 0.80);
+      flash(spaceDiagonal, gold);
+      roll3(3, 1.60, smooth);
+    }
+    wait(2.20);
+  }
+}

package/examples/tree-of-leaves.manic

@@ -0,0 +1,215 @@
+// tree-of-leaves — the full lifecycle cut. One seed, one year, one clock.
+// Everything is still a pure function of index i and time t (scrub-safe, no
+// state): four clouds now tell a complete story --
+//   stars  (220)   - twinkling night sky
+//   wood   (1,500) - trunk + five branches, grown by a front after the seed lands
+//   leaves (5,500) - golden-angle canopy; each leaf POPS (spring), flutters,
+//                    turns autumn-coloured on its own clock, FALLS in the gust,
+//                    fades into the soil over winter... and RETURNS, green again
+//   bloom  (1,200) - blossoms that open on the young canopy, shed their petals
+//                    in a slow petal-snow, and bloom once more at the end
+// 8,420 points - one small formula each.
+// Idioms: max(0,s) = 0.5*(s+abs(s));  min(a,b) = a - max(0, a-b);
+//         hash(i)  = mod(abs(sin(i*12.9898)*43758.55), 1)
+//
+//   manic tree-of-leaves.manic
+title("A Seed, a Tree, a Year");
+canvas("9:16");
+template("black");
+
+// ---------- HUD ----------
+text(head, (540, 150), "A Seed, a Tree, a Year"); display(head); cursor(head);
+text(season, (540, 330), ""); size(season, 34); color(season, lime);
+text(cap, (540, 1800), ""); size(cap, 30);
+counter(nlv, (540, 255), 0, 0, "leaves ", ""); color(nlv, lime); hidden(nlv);
+
+// ---------- stage ----------
+circle(moon, (880, 235), 62); color(moon, #f6e7c0); glow(moon, 20); hidden(moon);
+line(gnd, (60, 1668), (1020, 1668)); stroke(gnd, 3); color(gnd, dim); untraced(gnd);
+dot(seed, (540, 290), 9); color(seed, gold); glow(seed, 10); hidden(seed);
+
+// ---------- the night sky: 220 twinkling stars ----------
+cloud(stars, 220, #ffffff, 0.5) {
+  let rn = mod(abs(sin(i * 91.17) * 4375.8), 1);
+  let rn2 = mod(abs(sin(i * 45.7) * 7919.3), 1);
+  let x = 40 + rn * 1000;
+  let y = 60 + rn2 * 500;
+  let tw = 0.5 + 0.5 * sin(2 * t + i * 1.3);
+  let r = (0.6 + rn * 1.2) * tw * tanh(t) + 0.3;
+  let hue = 200 + rn * 40;
+}
+
+// ---------- the wood: grows out of the planted seed (front starts t~3.6) ----
+cloud(wood, 1500, #ffffff, 0.5) {
+  let p = i / 1500;
+  let b = mod(i, 5);
+  let rn = mod(abs(sin(i * 12.9898) * 43758.55), 1);
+  let rn2 = mod(abs(sin(i * 78.233) * 12543.7), 1);
+  let q = 0.5 * ((2 * p - 1) + abs(2 * p - 1));
+  let pt = 2 * p - q;
+  let tx = 540 + (b - 2) * 175;
+  let ty = 800 + abs(b - 2) * 95;
+  let sx = 540 + 18 * sin(3.1 * pt) + (tx - 540) * q + 12 * sin(3.14159 * q) * (b - 2) * 0.3;
+  let sy = 1660 - 510 * pt + (ty - 1150) * q;
+  let wid = 26 * (1 - 0.7 * pt) * (1 - 0.55 * q) + 3;
+  let jx = (rn - 0.5) * 2 * wid;
+  let jy = (rn2 - 0.5) * 14;
+  // wind, with the cold gust that strips the tree near t = 19
+  let hgt = (1660 - sy) / 900;
+  let gd = t - 19;
+  let gust = 1 + 1.3 * exp(-0.4 * gd * gd);
+  let wind = 14 * sin(0.9 * t + 0.004 * sy) * hgt * hgt * gust;
+  // growth front: sweeps p = 0..1 starting when the seed has been planted
+  let sv = tanh((0.3 * (t - 3.6) - p) * 5);
+  let vfront = 0.5 * (sv + abs(sv));
+  let x = sx + jx + wind;
+  let y = sy + jy;
+  let r = (2.2 + 2.2 * (1 - pt) * (1 - q)) * vfront;
+  let hue = 22 + rn * 14;
+}
+
+// ---------- the leaves: pop, flutter, turn, fall, fade... and RETURN --------
+cloud(leaves, 5500, #ffffff, 0.5) {
+  let b = mod(i, 5);
+  let k = floor(i / 5);
+  let rn = mod(abs(sin(i * 12.9898) * 43758.55), 1);
+  let rn2 = mod(abs(sin(i * 78.233) * 12543.7), 1);
+  let tx = 540 + (b - 2) * 175;
+  let ty = 800 + abs(b - 2) * 95;
+  let th = k * 2.39996;
+  let rad = 10.5 * sqrt(mod(k, 210)) + 8 * rn;
+  let bx = tx + rad * cos(th);
+  let by = ty + 0.78 * rad * sin(th) - 25;
+  let px = bx + (540 - bx) * 0.10;
+  let py = by + (860 - by) * 0.10;
+  // spring: each leaf unfurls on its own delay (t ~ 6.4 .. 8.8)
+  let ap0 = tanh((t - 6.4 - 2.4 * rn) * 2.2);
+  let ap = 0.5 * (ap0 + abs(ap0));
+  // wind + flutter, gusting near t = 19
+  let hgt = (1660 - py) / 900;
+  let gd = t - 19;
+  let gust = 1 + 1.3 * exp(-0.4 * gd * gd);
+  let wind = 26 * sin(0.9 * t + 0.004 * py + 2 * rn) * hgt * hgt * gust;
+  let fl = 4 * sin(2.3 * t + 1.7 * i);
+  // autumn: green -> gold/red, each leaf at its own pace (t ~ 16 .. 20)
+  let au0 = (t - 16 - 2.2 * rn) * 0.5;
+  let au1 = 0.5 * (au0 + abs(au0));
+  let au = au1 - 0.5 * ((au1 - 1) + abs(au1 - 1));
+  // the fall: EVERY leaf lets go this time (t ~ 19.5 .. 23), sways down, lands
+  let s2 = t - 19.5 - 3.5 * rn2;
+  let dt = 0.5 * (s2 + abs(s2));
+  let yfree = py + 55 * dt * dt;
+  let yg = 1665 + 20 * rn;
+  let yfall = yfree - 0.5 * ((yfree - yg) + abs(yfree - yg));
+  let sway = 30 * sin(2.2 * dt + i) * tanh(dt) * exp(-0.10 * dt);
+  // winter: the fallen fade into the soil (t ~ 24.5 .. 27.5)
+  let go0 = tanh((t - 24.5 - 1.6 * rn) * 1.6);
+  let gone = 0.5 * (go0 + abs(go0));
+  // spring again: a NEW leaf opens at the same spot on the branch (t ~ 27 .. 30)
+  let rb0 = tanh((t - 27 - 2.2 * rn) * 2.0);
+  let rb = 0.5 * (rb0 + abs(rb0));
+  // two position tracks, blended: the falling track and the fresh canopy track
+  let xfall = px + wind * (1 - tanh(2 * dt)) + fl + sway;
+  let xcan = px + wind + fl;
+  let x = xfall * (1 - rb) + xcan * rb;
+  let y = yfall * (1 - rb) + py * rb;
+  let r = (2.6 + 1.8 * rn2) * (ap * (1 - gone) + rb);
+  // hue: green, autumn-shifted, reset to green by rebirth
+  let hgr = 96 + 36 * rn;
+  let hau = 18 + 34 * rn2;
+  let hue = hgr + (hau - hgr) * au * (1 - rb);
+}
+
+// ---------- the blossoms: open on the young tree, shed petal-snow, return ---
+cloud(bloom, 1200, #ffffff, 0.5) {
+  let b = mod(i, 5);
+  let k = floor(i / 5);
+  let rn = mod(abs(sin(i * 12.9898) * 43758.55), 1);
+  let rn2 = mod(abs(sin(i * 78.233) * 12543.7), 1);
+  let tx = 540 + (b - 2) * 175;
+  let ty = 800 + abs(b - 2) * 95;
+  let th = k * 2.39996 + 1.3;
+  let rad = 21 * sqrt(mod(k, 48)) + 6 * rn;
+  let bx = tx + rad * cos(th);
+  let by = ty + 0.78 * rad * sin(th) - 25;
+  let px = bx + (540 - bx) * 0.10;
+  let py = by + (860 - by) * 0.10;
+  // first bloom: t ~ 9 .. 11.3
+  let bp0 = tanh((t - 9 - 1.8 * rn) * 2.4);
+  let bp = 0.5 * (bp0 + abs(bp0));
+  // petal-snow: slow drift down from t ~ 12.2, landing softly
+  let s2 = t - 12.2 - 2.2 * rn2;
+  let dt = 0.5 * (s2 + abs(s2));
+  let yfree = py + 16 * dt * dt + 30 * dt;
+  let yg = 1662 + 22 * rn;
+  let yfall = yfree - 0.5 * ((yfree - yg) + abs(yfree - yg));
+  let sway = 40 * sin(1.8 * dt + i) * tanh(dt);
+  // fallen petals melt away t ~ 18 .. 20.4 (before the leaf carpet arrives)
+  let go0 = tanh((t - 18 - 1.2 * rn) * 1.8);
+  let gone = 0.5 * (go0 + abs(go0));
+  // the second bloom, right at the end: the cycle begins again (t ~ 30.5+)
+  let rb0 = tanh((t - 30.5 - 1.2 * rn) * 2.6);
+  let rb = 0.5 * (rb0 + abs(rb0));
+  let hgt = (1660 - py) / 900;
+  let wind = 20 * sin(0.9 * t + 0.004 * py + 2 * rn) * hgt * hgt;
+  let xfall = px + wind * (1 - tanh(2 * dt)) + sway;
+  let xcan = px + wind + 3 * sin(2.1 * t + i);
+  let x = xfall * (1 - rb) + xcan * rb;
+  let y = yfall * (1 - rb) + py * rb;
+  let tw = 1 + 0.15 * sin(3 * t + i);
+  let r = (2.2 + 1.6 * rn2) * (bp * (1 - gone) + rb) * tw;
+  let hue = 318 + 26 * rn;
+}
+
+// ================= timeline (narration over the self-evolving year) =========
+type(head, 1.1);
+par { show(moon, 0.8); draw(gnd, 0.8); }
+
+// ---- the seed
+say(cap, "it begins with a single seed", 0.5);
+show(seed, 0.3);
+shift(seed, (0, 1355), 1.0, in);
+cue(pop);
+fade(seed, 0.5);
+
+// ---- spring: sprout and first leaves
+par { say(cap, "a sprout reaches for the sky", 0.5); say(season, "spring", 0.3); }
+wait(2.0);
+say(cap, "first leaves unfurl, one by one", 0.5);
+show(nlv, 0.3);
+to(nlv, value, 5500, 2.6, smooth);
+
+// ---- the flowering
+say(cap, "and then - the tree FLOWERS", 0.5);
+cue(chime);
+wait(1.8);
+
+// ---- summer: petal-snow
+par { say(cap, "petals drift away... summer settles in", 0.5); say(season, "summer", 0.3); recolor(season, gold, 0.3); }
+wait(3.0);
+
+// ---- autumn
+par { say(cap, "autumn arrives, one leaf at a time", 0.5); say(season, "autumn", 0.3); recolor(season, orange, 0.3); }
+cue(tick);
+wait(2.6);
+
+// ---- the gust: every leaf lets go
+say(cap, "a cold wind - and every leaf lets go", 0.5);
+cue(whoosh);
+to(nlv, value, 0, 4.6, smooth);
+
+// ---- winter
+par { say(cap, "winter: the tree remembers in silence", 0.5); say(season, "winter", 0.3); recolor(season, cyan, 0.3); }
+wait(2.2);
+
+// ---- spring again
+par { say(cap, "...and then, again", 0.5); say(season, "spring, again", 0.3); recolor(season, lime, 0.3); }
+cue(whoosh);
+to(nlv, value, 5500, 3.0, smooth);
+say(cap, "new leaves - and new flowers", 0.5);
+cue(chime);
+wait(2.6);
+
+// ---- close
+say(cap, "a seed, a tree, a year - 8,420 points, one formula each", 0.6);
+wait(2.5);

package/examples/triangle.manic

@@ -0,0 +1,68 @@
+// Triangle Geometry — the geo kit (olympiad helpers à la olympiad.asy/cse5.asy).
+// Points drive everything: circumcircle, incircle, centroid, circumcenter,
+// angle mark, and the foot of an altitude are all *constructed* from A, B, C.
+//
+//   manic examples/triangle.manic
+//   manic examples/triangle.manic --record out --fps 60
+
+title("Triangle Geometry");
+canvas(1280, 720);
+
+text(head, (640, 118), "constructed from three points");
+display(head);  color(head, cyan);  size(head, 32);  hidden(head);
+text(cap, (640, 668), "");  color(cap, dim);  size(cap, 22);
+
+// the three free points
+point(A, (380, 560), "A");
+point(B, (900, 560), "B");
+point(C, (640, 190), "C");
+hidden(A);  hidden(B);  hidden(C);
+
+// sides
+segment(ab, A, B);  segment(bc, B, C);  segment(ca, C, A);
+untraced(ab);  untraced(bc);  untraced(ca);
+
+// constructions
+circumcircle(cc, A, B, C);      untraced(cc);
+circumcenter(O, A, B, C);       hidden(O);
+incircle(ic, A, B, C);          untraced(ic);
+centroid(G, A, B, C);           hidden(G);
+anglemark(angC, A, C, B);       untraced(angC);
+foot(F, C, A, B);               hidden(F);
+segment(alt, C, F);             untraced(alt);
+
+// --- script ---
+show(head, 0.5);
+say(cap, "three points make a triangle");
+par { show(A);  show(B);  show(C); }
+par { draw(ab, 0.5);  draw(bc, 0.5);  draw(ca, 0.5); }
+draw(angC, 0.4);
+wait(0.5);
+
+section("Circumcircle");
+say(cap, "the unique circle through all three vertices");
+par { show(O);  draw(cc, 0.9); }
+wait(0.6);
+
+section("Incircle & Centroid");
+say(cap, "incircle (tangent to all sides) and centroid");
+par { draw(ic, 0.9);  show(G); }
+wait(0.6);
+
+section("Altitude");
+say(cap, "drop a perpendicular from C to AB — its foot F");
+par { show(F);  draw(alt, 0.6); }
+flash(F, magenta);
+wait(1.0);
+
+// the payoff: constructions are dynamic — drag a vertex and everything
+// (circumcircle, incircle, centroid, foot, angle mark, sides) recomputes.
+section("Drag a vertex");
+say(cap, "move C — every construction follows");
+move(C, (430, 230), 1.2, smooth);
+move(C, (850, 210), 1.2, smooth);
+move(C, (640, 190), 1.0, smooth);
+say(cap, "and drag A");
+move(A, (300, 520), 0.9, smooth);
+move(A, (380, 560), 0.8, smooth);
+wait(1.2);