@maniclang/workbench 0.1.11

package/examples/glsl-shapes.manic

@@ -0,0 +1,122 @@
+// glsl-shapes — Patricio Gonzalez Vivo's 2015 "shapes" Shadertoy, running in manic
+// UNCHANGED via the raw glsl() V3 path (2-D SDF gallery: pentagon/sphere/triangle/
+// octagon/hexagon/star/ellipse/rounded-rect, banded by an oscillating iso-line).
+//   Original: http://patriciogonzalezvivo.com  ·  @patriciogv
+canvas("16:9");
+template("black");
+
+glsl(scene, `
+float osc(float d){
+    return floor(mod((d+iTime*2.600)/2.,1.)*2.);
+}
+float sphere(vec2 p, float r){
+    return length(p)-r;
+}
+float tri( in vec2 p, in float r ){
+    const float k = sqrt(3.0);
+    p.x = abs(p.x) - r;
+    p.y = p.y + r/k;
+    if( p.x+k*p.y>0.0 ) p = vec2(p.x-k*p.y,-k*p.x-p.y)/2.0;
+    p.x -= clamp( p.x, -2.0*r, 0.0 );
+    return -length(p)*sign(p.y);
+}
+float pent( in vec2 p, in float r ){
+    const vec3 k = vec3(0.809016994,0.587785252,0.726542528);
+    p.x = abs(p.x);
+    p -= 2.0*min(dot(vec2(-k.x,k.y),p),0.0)*vec2(-k.x,k.y);
+    p -= 2.0*min(dot(vec2( k.x,k.y),p),0.0)*vec2( k.x,k.y);
+    p -= vec2(clamp(p.x,-r*k.z,r*k.z),r);
+    return length(p)*sign(p.y);
+}
+float oct( in vec2 p, in float r ){
+    const vec3 k = vec3(-0.9238795325, 0.3826834323, 0.4142135623 );
+    p = abs(p);
+    p -= 2.0*min(dot(vec2( k.x,k.y),p),0.0)*vec2( k.x,k.y);
+    p -= 2.0*min(dot(vec2(-k.x,k.y),p),0.0)*vec2(-k.x,k.y);
+    p -= vec2(clamp(p.x, -k.z*r, k.z*r), r);
+    return length(p)*sign(p.y);
+}
+float hex( in vec2 p, in float r ){
+    const vec4 k = vec4(-0.5,0.8660254038,0.5773502692,1.7320508076);
+    p = abs(p);
+    p -= 2.0*min(dot(k.xy,p),0.0)*k.xy;
+    p -= 2.0*min(dot(k.yx,p),0.0)*k.yx;
+    p -= vec2(clamp(p.x,r*k.z,r*k.w),r);
+    return length(p)*sign(p.y);
+}
+float str(in vec2 p, in float r, in float rf){
+    const vec2 k1 = vec2(0.809016994375, -0.587785252292);
+    const vec2 k2 = vec2(-k1.x,k1.y);
+    p.x = abs(p.x);
+    p -= 2.0*max(dot(k1,p),0.0)*k1;
+    p -= 2.0*max(dot(k2,p),0.0)*k2;
+    p.x = abs(p.x);
+    p.y -= r;
+    vec2 ba = rf*vec2(-k1.y,k1.x) - vec2(0,1);
+    float h = clamp( dot(p,ba)/dot(ba,ba), 0.0, r );
+    return length(p-ba*h) * sign(p.y*ba.x-p.x*ba.y);
+}
+float elp( in vec2 p, in vec2 ab ){
+    p = abs(p); if( p.x > p.y ) {p=p.yx;ab=ab.yx;}
+    float l = ab.y*ab.y - ab.x*ab.x;
+    float m = ab.x*p.x/l;      float m2 = m*m;
+    float n = ab.y*p.y/l;      float n2 = n*n;
+    float c = (m2+n2-1.0)/3.0; float c3 = c*c*c;
+    float q = c3 + m2*n2*2.0;
+    float d = c3 + m2*n2;
+    float g = m + m*n2;
+    float co;
+    if( d<0.0 ){
+        float h = acos(q/c3)/3.0;
+        float s = cos(h);
+        float t = sin(h)*sqrt(3.0);
+        float rx = sqrt( -c*(s + t + 2.0) + m2 );
+        float ry = sqrt( -c*(s - t + 2.0) + m2 );
+        co = (ry+sign(l)*rx+abs(g)/(rx*ry)- m)/2.0;
+    } else {
+        float h = 2.0*m*n*sqrt( d );
+        float s = sign(q+h)*pow(abs(q+h), 1.0/3.0);
+        float u = sign(q-h)*pow(abs(q-h), 1.0/3.0);
+        float rx = -s - u - c*4.0 + 2.0*m2;
+        float ry = (s - u)*sqrt(3.0);
+        float rm = sqrt( rx*rx + ry*ry );
+        co = (ry/sqrt(rm-rx)+2.0*g/rm-m)/2.0;
+    }
+    vec2 r = ab * vec2(co, sqrt(1.0-co*co));
+    return length(r-p) * sign(p.y-r.y);
+}
+float rnd( in vec2 p, in float w, in float r ){
+    p = abs(p);
+    return length(p-min(p.x+p.y,w)*0.5) - r;
+}
+
+vec2 cent = vec2(0.480,0.480);
+float line = 0.008;
+float spac = 0.0;
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord ){
+    vec2 st = fragCoord/iResolution.xy * vec2( iResolution.x/iResolution.y, 1. );
+    vec3 col = vec3(1.0);
+
+    float d = pent(st-cent,0.076);
+    d = min(d,sphere(st-vec2(0.750,0.800),0.076));
+    d = min(d,tri(st-vec2(0.210,0.790),0.076));
+    d = min(d,oct(st-vec2(0.160,0.260),0.076));
+    d = min(d,hex(st-vec2(0.200,0.500),0.036));
+    d = min(d,str(st-vec2(0.790,0.510),0.108,0.640));
+    d = min(d,elp(st-vec2(0.630,0.170),vec2(0.280,0.100)));
+    d = min(d,rnd(st-vec2(0.480,0.790),0.284,0.032));
+
+    float band = osc(d*200.*0.288);
+    if(d > spac && d < spac+line){
+        col = vec3(1.);
+    } else if(d > 0.0){
+        col*= vec3(1.000,0.684,0.364)*(1.-band)+vec3(1.000,0.514,0.128)*band;
+    } else {
+        col*= vec3(0.431,0.436,1.000)*(1.-band)+vec3(0.270,0.190,1.000)*band;
+    }
+    fragColor = vec4(col,1.0);
+}
+`);
+
+wait(8);

package/examples/gradient-descent-field.manic

@@ -0,0 +1,116 @@
+// GRADIENT DESCENT AS A LEARNING STORY
+// Twelve guesses begin without the answer. Every arrow supplies one local
+// correction, and the same authored field carries all of them to one minimum.
+
+title("How a Wrong Guess Learns");
+canvas("9:16");
+template("blank");
+
+watermark(mark,(w*0.16,h*0.045),"Made With Manic");
+text(kicker,(cx,h*0.075),"GRADIENT DESCENT · LEARNING AS MOTION");
+text(headline,(cx,h*0.125),"How does a wrong guess find the minimum?");
+text(chapter,(cx,h*0.265),"1 · START ANYWHERE");
+text(caption,(cx,h*0.78),"Twelve guesses begin with no map of the whole landscape.");
+text(result,(cx,h*0.715),"12 STARTING POINTS  →  1 SHARED MINIMUM");
+text(cta,(cx,h*0.91),"MAKE LEARNING VISIBLE → 8gwifi.org/manic");
+
+size(kicker,18); color(kicker,dim); bold(kicker); hidden(kicker);
+size(headline,32); bold(headline); wrap(headline,w*0.84); hidden(headline);
+size(chapter,19); color(chapter,cyan); bold(chapter); hidden(chapter);
+size(caption,21); color(caption,dim); wrap(caption,w*0.84); hidden(caption);
+size(result,19); color(result,lime); bold(result); hidden(result);
+size(cta,21); color(cta,cyan); bold(cta); hidden(cta);
+
+equation(lossRule,(cx,h*0.205),`L(x,y)=\frac{1}{2}x^2+y^2`);
+size(lossRule,34); color(lossRule,fg); hidden(lossRule);
+
+let fieldY = h*0.49;
+rect(domain,(cx,fieldY),w*0.82,h*0.40);
+outlined(domain); outline(domain,dim); stroke(domain,3);
+hidden(domain);
+
+// -grad L = (-x,-2y). The gentler vertical coefficient keeps the motion
+// readable while preserving the elliptical convergence of the loss bowl.
+vectorfield(descent,(cx,fieldY),w*0.37,h*0.175,"-x","-1.6*y",17);
+untraced(descent);
+
+circle(starts,(cx,fieldY),w*0.255);
+outlined(starts); outline(starts,dim); dashed(starts,12,10);
+hidden(starts);
+
+particles(guesses,starts,12,8,73,"ring");
+color(guesses,magenta); glow(guesses,0.78);
+hidden(guesses);
+
+circle(minimum,(cx,fieldY),14);
+filled(minimum); color(minimum,lime); glow(minimum,1.0);
+hidden(minimum);
+
+circle(targetRing,(cx,fieldY),44);
+outlined(targetRing); outline(targetRing,lime); stroke(targetRing,3);
+hidden(targetRing);
+
+text(minLabel,(cx,fieldY+74),"minimum");
+size(minLabel,19); color(minLabel,lime); bold(minLabel); hidden(minLabel);
+
+step("begin with imperfect guesses") {
+  par {
+    show(kicker,0.30);
+    show(headline,0.45);
+    show(lossRule,0.45);
+    show(chapter,0.35);
+    show(caption,0.40);
+    show(domain,0.45);
+    show(starts,0.45);
+    show(guesses,0.60);
+  }
+}
+wait(0.65);
+
+step("reveal one local clue everywhere") {
+  par {
+    draw(descent,1.10);
+    fade(starts,0.45);
+    say(chapter,"2 · READ THE LOCAL SLOPE",0.35);
+    say(caption,"Every arrow gives one instruction: move opposite the local gradient.",0.42);
+  }
+}
+wait(0.55);
+
+step("improve one small step at a time") {
+  par {
+    advect(guesses,descent,6.80,0.32);
+    seq {
+      say(chapter,"3 · FOLLOW THE CORRECTIONS",0.35);
+      say(caption,"Far away, the correction is large. Near the bottom, each adjustment becomes smaller.",0.42);
+      wait(3.05);
+      say(caption,"Different starting points take different journeys—but obey the same rule.",0.42);
+    }
+  }
+}
+wait(0.55);
+
+step("discover the shared destination") {
+  par {
+    show(minimum,0.35);
+    show(targetRing,0.40);
+    show(minLabel,0.35);
+    show(result,0.45);
+    say(chapter,"4 · ARRIVE WITHOUT TELEPORTING",0.35);
+    say(caption,"Gradient descent is not a jump to the answer. It is repeated, measured improvement.",0.42);
+    seq {
+      pulse(targetRing,0.70);
+      pulse(guesses,0.70);
+    }
+  }
+}
+wait(0.75);
+
+step("create with Manic") {
+  par {
+    pulse(minimum,0.75);
+    show(cta,0.45);
+    say(caption,"Describe the rule once. Manic keeps every guess, arrow, correction, and learning step connected.",0.45);
+  }
+}
+wait(1.45);

package/examples/gradient-fastest-descent-shorts.manic

@@ -0,0 +1,153 @@
+// ============================================================================
+//  gradient-fastest-descent-shorts.manic — Bernoulli's brachistochrone as a
+//  9:16 cinematic short, told THROUGH gradients
+//  (companion: gradient-fastest-descent.manic, the 16:9 cut)
+// ----------------------------------------------------------------------------
+//  THE PROBLEM (Bernoulli, 1696): which wire gets a bead from A to B fastest?
+//  THE GRADIENTS: every ramp is a vertical 3-stop speedometer
+//  (v = √(2gΔh) — depth IS speed); the winner's secret is a curvature gradient.
+//
+//  Pattern mirrors creator-free-kicks.manic: hook → setup → race → secret →
+//  endcard. Every curve and bead is RK4, not drawn.
+// ============================================================================
+
+title("The Fastest Descent");
+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=gold footer=signature cta=Try_it_free safe=reels");
+watermark(mk, (w*0.955-100, h*0.045+24), "Made With Manic");
+
+// ---- backdrop ----
+circle(stage, (cx, h*0.42), w*0.55);
+filled(stage);
+gradient(stage, panel, void, radial);
+opacity(stage, 0.55);
+
+// ---- the race, sized for portrait: A upper-left, B lower-right ----
+let rx = w*0.14;
+let ry = h*0.30;
+let ru = w*0.22;
+brachistochrone(race, (rx, ry), ru);
+untraced(race.straight); untraced(race.circle); untraced(race.parabola); untraced(race.cycloid);
+hidden(race.bead_straight); hidden(race.bead_circle); hidden(race.bead_parabola); hidden(race.bead_cycloid);
+hidden(race.markA); hidden(race.labelA); hidden(race.markB); hidden(race.labelB);
+stroke(race.straight, 4); stroke(race.circle, 4); stroke(race.parabola, 4); stroke(race.cycloid, 6);
+opacity(race.straight, 0.95); opacity(race.circle, 0.95); opacity(race.parabola, 0.95); opacity(race.cycloid, 1);
+
+// depth IS speed — blue high (potential), gold low (kinetic)
+gradient(race.straight, gold, cyan, blue, 270);
+gradient(race.circle,   gold, cyan, blue, 270);
+gradient(race.parabola, gold, cyan, blue, 270);
+gradient(race.cycloid,  gold, cyan, blue, 270);
+
+// ghost cycloid for the curvature reveal
+brachistochrone(ghost, (rx, ry), ru);
+hidden(ghost.straight); hidden(ghost.circle); hidden(ghost.parabola);
+hidden(ghost.bead_straight); hidden(ghost.bead_circle); hidden(ghost.bead_parabola); hidden(ghost.bead_cycloid);
+hidden(ghost.markA); hidden(ghost.labelA); hidden(ghost.markB); hidden(ghost.labelB);
+hidden(ghost.cycloid); untraced(ghost.cycloid);
+stroke(ghost.cycloid, 7);
+gradient(ghost.cycloid, dim, magenta, "curvature");
+glow(ghost.cycloid, 0.7);
+
+// ---- typography ----
+text(kicker, (cx, h*0.11), "shortest path — or fastest?");
+size(kicker, 32); color(kicker, gold); bold(kicker); wrap(kicker, w*0.84);
+untraced(kicker); cursor(kicker);
+
+equation(law, (cx, h*0.62), `v=\sqrt{2g\,\Delta h}`, 38);
+color(law, cyan); hidden(law);
+
+text(cap, (cx, h*0.74), ""); size(cap, 28); color(cap, dim); wrap(cap, w*0.86);
+
+socials(me);
+endcard(me, "title=Try_Manic cta=8gwifi.org/manic");
+
+// ============================== SCRIPT ==============================
+
+// 1 — HOOK.
+mark("hook");
+type(kicker, 1.2);
+
+// 2 — THE PROBLEM.
+show(cap, 0.3);
+say(cap, "Bernoulli, 1696 — a bead slides from A down to B. Gravity only.");
+par {
+  show(race.markA, 0.35); show(race.labelA, 0.25);
+  show(race.markB, 0.35); show(race.labelB, 0.25);
+}
+pulse(race.markA); pulse(race.markB);
+wait(0.4);
+
+// 3 — FOUR WIRES, each a height→speed color bar.
+say(cap, "four wires — colored by depth, and depth IS speed");
+stagger(0.12) {
+  draw(race.straight, 0.65);
+  draw(race.circle, 0.65);
+  draw(race.parabola, 0.65);
+  draw(race.cycloid, 0.85);
+}
+show(law, 0.45);
+wait(0.5);
+say(cap, "blue = potential · gold = all of it cashed into speed");
+wait(0.7);
+
+// 4 — THE RACE.
+say(cap, "release all four at once …");
+par {
+  show(race.bead_straight, 0.2);
+  show(race.bead_circle, 0.2);
+  show(race.bead_parabola, 0.2);
+  show(race.bead_cycloid, 0.2);
+}
+run(race, 5.5);
+
+// 5 — THE WINNER.
+recolor(cap, gold);
+say(cap, "the CYCLOID wins — the straight line isn't even close");
+flash(race.cycloid, magenta);
+glow(race.bead_cycloid, 1.9);
+pulse(race.bead_cycloid);
+wait(0.7);
+
+// 6 — THE SECRET: curvature gradient.
+recolor(cap, dim);
+say(cap, "its secret, colored by curvature — it bends hardest at the start");
+par {
+  fade(race.straight, 0.4);
+  fade(race.circle, 0.4);
+  fade(race.parabola, 0.4);
+  fade(race.cycloid, 0.4);
+  fade(race.bead_straight, 0.35);
+  fade(race.bead_circle, 0.35);
+  fade(race.bead_parabola, 0.35);
+  fade(race.bead_cycloid, 0.35);
+  fade(law, 0.35);
+}
+show(ghost.cycloid, 0.15);
+draw(ghost.cycloid, 1.3);
+wait(0.35);
+say(cap, "a near-vertical dive buys gold-speed immediately");
+flash(ghost.cycloid, magenta);
+wait(0.8);
+
+// 7 — POINT + ENDCARD.
+recolor(cap, cyan);
+say(cap, "every color is computed — depth is the speedometer, the bend is the strategy");
+wait(0.9);
+
+mark("endcard");
+par {
+  fade(cap, 0.4);
+  fade(me.footer, 0.4);
+  fade(kicker, 0.4);
+  fade(ghost.cycloid, 0.4);
+  fade(race.cycloid, 0.4);
+  fade(race.bead_cycloid, 0.4);
+  fade(race.markA, 0.3); fade(race.markB, 0.3);
+  fade(race.labelA, 0.3); fade(race.labelB, 0.3);
+  fade(stage, 0.4);
+}
+show(me.endcard, 0.6);
+wait(1.6);

package/examples/gradient-fastest-descent.manic

@@ -0,0 +1,125 @@
+// ============================================================================
+//  gradient-fastest-descent.manic — a 3B1B-style 16:9 story told THROUGH
+//  gradients (companion: gradient-fastest-descent-shorts.manic)
+// ----------------------------------------------------------------------------
+//  THE PROBLEM (Bernoulli, 1696): a bead slides from A down to B under gravity.
+//  Which wire shape gets it there fastest? Newton, Leibniz and the Bernoullis
+//  all answered: the CYCLOID — not the straight line.
+//
+//  THE GRADIENTS DO THE PHYSICS:
+//   · every ramp wears a 3-stop vertical gradient — for a frictionless bead
+//     v = √(2gΔh), so DEPTH IS SPEED and the color bar is a real speedometer
+//   · the winner's secret is revealed by a "curvature" gradient — the cycloid
+//     bends hardest at the very start, a near-vertical dive that buys speed
+//     immediately
+//   · a radial well sinks the stage behind the race
+//  Every curve, bead and color is computed (RK4 bead-on-wire), not drawn.
+// ============================================================================
+
+title("The Fastest Descent");
+canvas("16:9");
+template("blank");
+
+// ---- backdrop: a radial gravity well behind the race ----
+circle(stage, (cx, 380), 300);
+filled(stage);
+gradient(stage, panel, void, radial);
+opacity(stage, 0.4);
+
+// ---- the race: four wires from A to B, beads pre-integrated with RK4 ----
+brachistochrone(race, (300, 170), 155);
+untraced(race.straight); untraced(race.circle); untraced(race.parabola); untraced(race.cycloid);
+hidden(race.bead_straight); hidden(race.bead_circle); hidden(race.bead_parabola); hidden(race.bead_cycloid);
+hidden(race.markA); hidden(race.labelA); hidden(race.markB); hidden(race.labelB);
+stroke(race.straight, 4); stroke(race.circle, 4); stroke(race.parabola, 4); stroke(race.cycloid, 5);
+opacity(race.straight, 0.95); opacity(race.circle, 0.95); opacity(race.parabola, 0.95); opacity(race.cycloid, 1);
+
+// depth IS speed: v = √(2gΔh), so a vertical 3-stop gradient over each wire's
+// own bounds is its true speedometer — blue at the top (all potential),
+// gold at the bottom (all kinetic). 270 puts the first stop at the bottom.
+gradient(race.straight, gold, cyan, blue, 270);
+gradient(race.circle,   gold, cyan, blue, 270);
+gradient(race.parabola, gold, cyan, blue, 270);
+gradient(race.cycloid,  gold, cyan, blue, 270);
+
+// a second copy of the same sim: only its cycloid is used, re-dressed with a
+// CURVATURE gradient for the reveal — same computed curve, different truth
+brachistochrone(ghost, (300, 170), 155);
+hidden(ghost.straight); hidden(ghost.circle); hidden(ghost.parabola);
+hidden(ghost.bead_straight); hidden(ghost.bead_circle); hidden(ghost.bead_parabola); hidden(ghost.bead_cycloid);
+hidden(ghost.markA); hidden(ghost.labelA); hidden(ghost.markB); hidden(ghost.labelB);
+hidden(ghost.cycloid); untraced(ghost.cycloid);
+stroke(ghost.cycloid, 6);
+gradient(ghost.cycloid, dim, magenta, "curvature");
+glow(ghost.cycloid, 0.6);
+
+// ---- typography ----
+caption(q, "shortest path — or fastest?", (cx, 56), 34, gold);
+equation(law, (1020, 160), `v=\sqrt{2g\,\Delta h}`, 34);
+color(law, cyan); hidden(law);
+text(cap, (cx, h - 38), ""); size(cap, 20); color(cap, dim); display(cap);
+
+// ============================== SCRIPT ==============================
+
+// 1 — THE PROBLEM
+say(cap, "Bernoulli, 1696 — a bead slides from A down to B under gravity alone", 0.4);
+show(race.markA, 0.4); show(race.labelA, 0.3); pulse(race.markA);
+show(race.markB, 0.4); show(race.labelB, 0.3); pulse(race.markB);
+wait(0.3);
+wordpop(q, 0.18);
+wait(0.5);
+
+// 2 — THE CANDIDATES, each wearing its speedometer
+say(cap, "four wires — colored by depth, and depth IS speed", 0.4);
+stagger(0.15) {
+  draw(race.straight, 0.7);
+  draw(race.circle, 0.7);
+  draw(race.parabola, 0.7);
+  draw(race.cycloid, 0.9);
+}
+wait(0.3);
+
+show(law, 0.5);
+say(cap, "blue = all potential energy · gold = all of it cashed into speed", 0.4);
+wait(1.0);
+
+// 3 — THE RACE (real RK4 bead-on-wire integrations)
+say(cap, "release all four at once …", 0.4);
+par {
+  show(race.bead_straight, 0.25);
+  show(race.bead_circle, 0.25);
+  show(race.bead_parabola, 0.25);
+  show(race.bead_cycloid, 0.25);
+}
+run(race, 6);
+
+// 4 — THE WINNER
+say(cap, "the CYCLOID wins — the straight line isn't even close", 0.4);
+flash(race.cycloid, magenta);
+glow(race.bead_cycloid, 1.9);
+pulse(race.bead_cycloid);
+wait(0.8);
+
+// 5 — THE SECRET, told by a curvature gradient
+say(cap, "its secret, colored by curvature: it bends hardest at the very start", 0.4);
+par {
+  fade(race.straight, 0.5);
+  fade(race.circle, 0.5);
+  fade(race.parabola, 0.5);
+  fade(race.cycloid, 0.5);
+  fade(race.bead_straight, 0.4);
+  fade(race.bead_circle, 0.4);
+  fade(race.bead_parabola, 0.4);
+  fade(race.bead_cycloid, 0.4);
+}
+show(ghost.cycloid, 0.2);
+draw(ghost.cycloid, 1.4);
+wait(0.4);
+say(cap, "a near-vertical dive buys gold-speed immediately — then spends it on distance", 0.4);
+flash(ghost.cycloid, magenta);
+wait(1.0);
+
+// 6 — THE POINT
+recolor(cap, cyan);
+say(cap, "every color here is computed — depth is the speedometer, the bend is the strategy", 0.4);
+wait(1.6);

package/examples/gradient-pendulum-shorts.manic

@@ -0,0 +1,117 @@
+// ============================================================================
+//  gradient-pendulum-shorts.manic — a 9:16 cinematic short told THROUGH a
+//  "speed" gradient. Sister piece to the brachistochrone pair
+//  (gradient-fastest-descent.manic / gradient-fastest-descent-shorts.manic).
+// ----------------------------------------------------------------------------
+//  THE PROBLEM (Galileo, 1583): watching a chandelier swing in the Pisa
+//  cathedral, Galileo timed it with his own pulse. But WHERE along the arc is
+//  the bob fastest — and how would you ever see that?
+//
+//  THE GRADIENT DOES THE PHYSICS: the swing arc is a pre-simulated RK4
+//  trajectory, uniformly sampled in time — so gradient(p.path, ..., "speed")
+//  colors it by its TRUE local speed. Gold floods the bottom (all kinetic),
+//  blue pools at the ends (the bob stands still for an instant). Nothing is
+//  keyframed; the color IS the simulation.
+//
+//  Pattern mirrors creator-free-kicks.manic: hook → problem → reveal → law →
+//  prove on the painted arc → endcard.
+// ============================================================================
+
+title("Galileo's Chandelier");
+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=gold footer=signature cta=Try_it_free safe=reels");
+watermark(mk, (w*0.955-100, h*0.045+24), "Made With Manic");
+
+// ---- backdrop: a radial pool of light under the chandelier ----
+circle(halo, (cx, h*0.42), w*0.52);
+filled(halo);
+gradient(halo, panel, void, radial);
+opacity(halo, 0.8);
+
+// ---- the chandelier: a real RK4 pendulum, arc uniformly sampled in time ----
+pendulum(p, (cx, h*0.26), 1, 55, w*0.36);
+hidden(p.overlays);
+untraced(p.path);
+stroke(p.path, 7);
+opacity(p.path, 0.95);
+// the reveal: 3 stops by TRUE local speed — slowest first, fastest last
+gradient(p.path, blue, cyan, gold, "speed");
+color(p.bob, gold); glow(p.bob, 0.7);
+stroke(p.rod, 3);
+
+// ---- typography ----
+text(kicker, (cx, h*0.11), "where is a pendulum FASTEST?");
+size(kicker, 34); color(kicker, gold); bold(kicker); wrap(kicker, w*0.82);
+untraced(kicker); cursor(kicker);
+
+equation(law, (cx, h*0.64), `mgh \;=\; \tfrac{1}{2}mv^2`, 40);
+color(law, cyan); hidden(law);
+
+text(cap, (cx, h*0.76), ""); size(cap, 30); color(cap, dim); wrap(cap, w*0.84);
+
+socials(me);
+endcard(me, "title=Try_Manic cta=8gwifi.org/manic");
+
+// ============================== SCRIPT ==============================
+
+// 1 — HOOK.
+mark("hook");
+type(kicker, 1.2);
+
+// 2 — GALILEO'S PROBLEM.
+show(cap, 0.3);
+say(cap, "1583 — Galileo times a swinging chandelier with his own pulse");
+par {
+  show(p.pivot, 0.4);
+  show(p.rod, 0.4);
+  show(p.bob, 0.4);
+}
+pulse(p.bob);
+wait(0.4);
+
+// 3 — WATCH IT SWING. Your eye can't catch where it's quickest.
+say(cap, "watch it — can you SEE where it moves fastest?");
+swing(p, 4);
+wait(0.3);
+
+// 4 — THE REVEAL: paint the arc with its own speed.
+say(cap, "freeze — and color the arc by its true speed");
+draw(p.path, 1.8);
+wait(0.5);
+recolor(cap, gold);
+say(cap, "gold floods the bottom — blue pools at the tips, where it stops for an instant");
+flash(p.path, gold);
+wait(0.8);
+
+// 5 — WHY: energy. Height traded for speed, every swing, exactly.
+recolor(cap, dim);
+say(cap, "height falls, speed rises — energy just changes clothes");
+show(law, 0.5);
+wait(0.5);
+rewrite(law, `v=\sqrt{2gh}`, 0.8, smooth);
+say(cap, "at the lowest point ALL the height has become speed — that's the gold");
+wait(0.8);
+
+// 6 — PROVE IT: run the bob on its own painted speedometer.
+recolor(cap, cyan);
+say(cap, "the color is computed, not painted — a real RK4 swing on its own speedometer");
+swing(p, 4);
+wait(0.5);
+
+// 7 — END CARD.
+mark("endcard");
+par {
+  fade(cap, 0.4);
+  fade(me.footer, 0.4);
+  fade(law, 0.4);
+  fade(kicker, 0.4);
+  fade(p.path, 0.4);
+  fade(p.rod, 0.4);
+  fade(p.bob, 0.4);
+  fade(p.pivot, 0.4);
+  fade(halo, 0.4);
+}
+show(me.endcard, 0.6);
+wait(1.6);