@maniclang/workbench 0.1.11

package/examples/second-law-thermodynamics.manic

@@ -0,0 +1,385 @@
+// ============================================================================
+// second-law-thermodynamics.manic — entropy, irreversibility, and time's arrow
+// ----------------------------------------------------------------------------
+// Engine-test recreation of engine-test-4.mp4. The subject is thermodynamics,
+// but the vocabulary stays generic: persistent particles, authored layouts,
+// plots, counters, arrows, LaTeX, and ordinary timeline composition.
+// ============================================================================
+
+title("Second Law of Thermodynamics");
+canvas("9:16");
+template("mono");
+watermark(manicMark, (150, 145), "Made With Manic");
+
+let cold = 194;
+let pink = 326;
+let hot = 40;
+let blue = 226;
+let green = 154;
+let red = 10;
+
+// ---------------------------------------------------------------------------
+// 1 · MIXING MULTIPLIES THE NUMBER OF POSSIBLE MICROSTATES
+// ---------------------------------------------------------------------------
+
+equation(law, (540, 175), `S=k_B\ln\Omega`, 58);
+rect(mixBox, (540, 520), 720, 280);
+outline(mixBox, dim); outlined(mixBox); stroke(mixBox, 3);
+rect(mixLeft, (360, 520), 350, 260); hidden(mixLeft);
+rect(mixRight, (720, 520), 350, 260); hidden(mixRight);
+line(mixDivider, (540, 390), (540, 650)); color(mixDivider, dim); stroke(mixDivider, 2);
+
+particles(mixCold, mixLeft, 36, 6, 17);
+particles(mixWarm, mixRight, 36, 6, 29);
+hue(mixCold, cold, 0.72, 0.68); hue(mixWarm, pink, 0.72, 0.68);
+glow(mixCold, 0.8); glow(mixWarm, 0.8);
+
+text(mixCaption, (540, 745), "Mixing creates overwhelmingly more possible states");
+size(mixCaption, 27); color(mixCaption, dim);
+line(mixX, (260, 1040), (570, 1040)); line(mixY, (260, 1040), (260, 840));
+color(mixX, dim); color(mixY, dim); stroke(mixX, 2); stroke(mixY, 2);
+plot(mixCurve, (260, 1040), 78, 175, "1-exp(-2*x)", (0, 3.6));
+hue(mixCurve, blue, 0.55, 0.68); stroke(mixCurve, 4); untraced(mixCurve);
+dot(mixMarker, (260, 1040), 7); color(mixMarker, fg); glow(mixMarker, 1.0);
+equation(mixDelta, (385, 815), `\Delta S/(Nk_B\ln 2)`, 27); color(mixDelta, dim);
+counter(mixCount, (735, 945), 0, 1, "log₁₀(Ω/Ω₀) = ", "");
+size(mixCount, 28); hue(mixCount, hot, 0.45, 0.72);
+
+tag(mixBox, s1); tag(mixDivider, s1);
+tag(mixCold, s1); tag(mixWarm, s1); tag(mixCaption, s1);
+tag(mixX, s1); tag(mixY, s1); tag(mixCurve, s1); tag(mixMarker, s1); tag(mixDelta, s1); tag(mixCount, s1);
+
+// ---------------------------------------------------------------------------
+// 2 · HEAT FLOW MAKES TOTAL ENTROPY INCREASE
+// ---------------------------------------------------------------------------
+
+rect(hotBox, (315, 500), 260, 240); rect(coldBox, (765, 500), 260, 240);
+outline(hotBox, dim); outline(coldBox, dim); outlined(hotBox); outlined(coldBox);
+stroke(hotBox, 3); stroke(coldBox, 3);
+particles(hotMatter, hotBox, 26, 6, 41); particles(coldMatter, coldBox, 26, 6, 73);
+hue(hotMatter, hot, 0.66, 0.68); hue(coldMatter, blue, 0.66, 0.68);
+link(heatLink, hotBox, coldBox); hue(heatLink, blue, 0.46, 0.62); stroke(heatLink, 4);
+hidden(heatLink);
+equation(hotLabel, (315, 325), `T_h`, 36); equation(coldLabel, (765, 325), `T_c`, 36);
+hue(hotLabel, hot, 0.58, 0.72); hue(coldLabel, blue, 0.58, 0.72);
+counter(hotTemp, (315, 680), 403, 0, "", " K");
+counter(coldTemp, (765, 680), 397, 0, "", " K");
+hue(hotTemp, hot, 0.55, 0.70); hue(coldTemp, blue, 0.55, 0.70);
+text(flowCaption, (540, 780), "Heat flows until both sides reach one temperature");
+size(flowCaption, 27); color(flowCaption, dim);
+line(flowX, (305, 1130), (650, 1130)); line(flowY, (305, 1130), (305, 880));
+color(flowX, dim); color(flowY, dim); stroke(flowX, 2); stroke(flowY, 2);
+plot(flowCurve, (305, 1130), 78, 215, "1-exp(-2.4*x)", (0, 3.6));
+hue(flowCurve, blue, 0.56, 0.70); stroke(flowCurve, 4); untraced(flowCurve);
+dot(flowMarker, (305, 1130), 7); color(flowMarker, fg); glow(flowMarker, 1.0);
+equation(flowS, (430, 855), `S_{\mathrm{tot}}`, 30); color(flowS, dim);
+
+tag(hotBox, s2); tag(coldBox, s2); tag(hotMatter, s2); tag(coldMatter, s2);
+tag(hotLabel, s2); tag(coldLabel, s2); tag(hotTemp, s2); tag(coldTemp, s2);
+tag(flowCaption, s2); tag(flowX, s2); tag(flowY, s2); tag(flowCurve, s2); tag(flowMarker, s2); tag(flowS, s2);
+hidden(s2);
+
+// ---------------------------------------------------------------------------
+// 3 · FREE EXPANSION: ONE GAS, TWICE THE VOLUME
+// ---------------------------------------------------------------------------
+
+rect(expandBox, (540, 520), 720, 280); outline(expandBox, dim); outlined(expandBox); stroke(expandBox, 3);
+rect(expandLeft, (360, 520), 350, 260); hidden(expandLeft);
+line(expandDivider, (540, 390), (540, 650)); color(expandDivider, dim); stroke(expandDivider, 2);
+hidden(expandDivider);
+particles(expandGas, expandLeft, 54, 6, 101);
+hue(expandGas, cold, 0.38, 0.76); glow(expandGas, 0.7);
+text(expandCaption, (540, 745), "More volume means exponentially more possible states");
+size(expandCaption, 27); color(expandCaption, dim);
+line(expandX, (250, 1040), (560, 1040)); line(expandY, (250, 1040), (250, 845));
+color(expandX, dim); color(expandY, dim); stroke(expandX, 2); stroke(expandY, 2);
+plot(expandCurve, (250, 1040), 85, 60, "x", (0, 2.6));
+hue(expandCurve, green, 0.52, 0.70); stroke(expandCurve, 4); untraced(expandCurve);
+dot(expandMarker, (250, 1040), 7); color(expandMarker, fg); glow(expandMarker, 1.0);
+equation(expandAxis, (390, 820), `\ln(V/V_0)/\ln 2`, 27); color(expandAxis, dim);
+equation(expandStates, (760, 905), `V^N\longrightarrow(2V)^N`, 37);
+hue(expandStates, hot, 0.52, 0.70);
+counter(expandCount, (760, 1010), 8.9, 1, "log₁₀(Ω/Ω₀) = ", "");
+size(expandCount, 26); color(expandCount, dim);
+
+tag(expandBox, s3); tag(expandGas, s3);
+tag(expandCaption, s3); tag(expandX, s3); tag(expandY, s3); tag(expandCurve, s3);
+tag(expandMarker, s3); tag(expandAxis, s3); tag(expandStates, s3); tag(expandCount, s3);
+hidden(s3);
+
+// ---------------------------------------------------------------------------
+// 4 · A HEAT ENGINE CANNOT TURN EVERY JOULE INTO WORK
+// ---------------------------------------------------------------------------
+
+line(hotRail, (230, 410), (850, 410)); hue(hotRail, hot, 0.72, 0.65); stroke(hotRail, 5);
+line(coldRail, (230, 1200), (850, 1200)); hue(coldRail, blue, 0.72, 0.65); stroke(coldRail, 5);
+equation(hotRailLabel, (540, 365), `T_h`, 31); equation(coldRailLabel, (540, 1250), `T_c`, 31);
+hue(hotRailLabel, hot, 0.56, 0.70); hue(coldRailLabel, blue, 0.56, 0.70);
+line(engineX, (265, 1010), (805, 1010)); line(engineY, (265, 1010), (265, 555));
+color(engineX, dim); color(engineY, dim); stroke(engineX, 2); stroke(engineY, 2);
+equation(engineP, (250, 520), `p`, 28); equation(engineV, (835, 1010), `V`, 28);
+color(engineP, dim); color(engineV, dim);
+// Two paths share the hot state, separate during the cycle, and reconverge.
+// Each visible path is split only to carry the warm/cool colour progression;
+// the hidden whole paths give `travel` one continuous geometric route.
+plot(engineHotPath, (285, 990), 112, 235, "1/(x+0.65)+0.14+0.05*x*(4.1-x)", (0, 4.1));
+plot(engineColdPath, (285, 990), 112, 235, "1/(x+0.65)+0.14-0.035*x*(4.1-x)", (0, 4.1));
+hidden(engineHotPath); hidden(engineColdPath);
+plot(engineHotA, (285, 990), 112, 235, "1/(x+0.65)+0.14+0.05*x*(4.1-x)", (0, 1.55));
+plot(engineHotB, (285, 990), 112, 235, "1/(x+0.65)+0.14+0.05*x*(4.1-x)", (1.55, 4.1));
+plot(engineColdA, (285, 990), 112, 235, "1/(x+0.65)+0.14-0.035*x*(4.1-x)", (0, 1.85));
+plot(engineColdB, (285, 990), 112, 235, "1/(x+0.65)+0.14-0.035*x*(4.1-x)", (1.85, 4.1));
+hue(engineHotA, hot, 0.68, 0.70); hue(engineHotB, red, 0.58, 0.69);
+hue(engineColdA, 260, 0.52, 0.72); hue(engineColdB, blue, 0.62, 0.70);
+stroke(engineHotA, 5); stroke(engineHotB, 5); stroke(engineColdA, 5); stroke(engineColdB, 5);
+untraced(engineHotA); untraced(engineHotB); untraced(engineColdA); untraced(engineColdB);
+dot(engineDot, (285, 596), 8); color(engineDot, fg); glow(engineDot, 1.1); hidden(engineDot);
+arrow(qHot, (330, 410), (330, 610)); hue(qHot, hot, 0.72, 0.68); stroke(qHot, 4); untraced(qHot);
+equation(qHotLabel, (360, 525), `Q_h`, 28); hue(qHotLabel, hot, 0.56, 0.70); hidden(qHotLabel);
+arrow(workArrow, (650, 850), (875, 700)); color(workArrow, dim); stroke(workArrow, 4); untraced(workArrow);
+equation(workLabel, (880, 660), `W`, 28); color(workLabel, dim); hidden(workLabel);
+arrow(qCold, (675, 1000), (675, 1170)); hue(qCold, blue, 0.72, 0.68); stroke(qCold, 4); untraced(qCold);
+equation(qColdLabel, (735, 1090), `|Q_c|`, 28); hue(qColdLabel, blue, 0.56, 0.70); hidden(qColdLabel);
+text(engineCaption, (540, 1345), "A heat engine must release some heat");
+size(engineCaption, 30); hue(engineCaption, hot, 0.38, 0.74);
+equation(engineEta, (540, 1490), `\eta_C=1-\frac{T_c}{T_h}<1`, 47);
+
+// Persistent transition strokes preserve object identity between scenes:
+// entropy curve → heat connector → expansion divider, then the volume graph
+// seeds the heat-engine curve. All are ordinary generic `morph` paths.
+plot(mixToHeat, (260, 1040), 78, 175, "1-exp(-2*x)", (0, 3.6));
+hue(mixToHeat, blue, 0.55, 0.68); stroke(mixToHeat, 4);
+morph(mixToHeat, heatLink); hidden(mixToHeat);
+
+line(heatToExpand, (445, 500), (635, 500));
+hue(heatToExpand, blue, 0.46, 0.62); stroke(heatToExpand, 4);
+morph(heatToExpand, expandDivider); hidden(heatToExpand);
+
+line(engineSeed, (285, 596), (355, 790)); hidden(engineSeed);
+plot(expandToEngine, (250, 1040), 85, 60, "x", (0, 2.6));
+hue(expandToEngine, green, 0.52, 0.70); stroke(expandToEngine, 4);
+morph(expandToEngine, engineSeed); hidden(expandToEngine);
+
+tag(hotRail, s4); tag(coldRail, s4); tag(hotRailLabel, s4); tag(coldRailLabel, s4);
+tag(engineX, s4); tag(engineY, s4); tag(engineP, s4); tag(engineV, s4);
+tag(engineHotA, s4); tag(engineHotB, s4); tag(engineColdA, s4); tag(engineColdB, s4);
+tag(engineCaption, s4); tag(engineEta, s4);
+tag(engineDot, s4future); tag(qHot, s4future); tag(qHotLabel, s4future);
+tag(workArrow, s4future); tag(workLabel, s4future);
+tag(qCold, s4future); tag(qColdLabel, s4future);
+hidden(s4);
+
+// ---------------------------------------------------------------------------
+// 5 · SAME ENDPOINTS, DIFFERENT ENTROPY PRODUCTION
+// ---------------------------------------------------------------------------
+
+text(revHead, (300, 350), "REV. LIMIT"); text(irrHead, (780, 350), "IRREV");
+size(revHead, 28); size(irrHead, 28); hue(revHead, green, 0.45, 0.72); hue(irrHead, red, 0.55, 0.68);
+rect(revPanel, (300, 610), 330, 330); rect(irrPanel, (780, 610), 330, 330);
+outline(revPanel, dim); outline(irrPanel, dim); outlined(revPanel); outlined(irrPanel);
+stroke(revPanel, 3); stroke(irrPanel, 3);
+rect(revGasBox, (260, 610), 220, 210); rect(irrGasBox, (740, 610), 220, 210);
+hidden(revGasBox); hidden(irrGasBox);
+rect(revSmall, (215, 610), 120, 210); rect(irrSmall, (695, 610), 120, 210);
+hidden(revSmall); hidden(irrSmall);
+particles(revGas, revGasBox, 20, 5, 131, "grid");
+particles(irrGas, irrGasBox, 20, 5, 151, "grid");
+hue(revGas, green, 0.55, 0.72); hue(irrGas, red, 0.58, 0.68);
+line(revPiston, (405, 505), (405, 715)); line(irrPiston, (885, 505), (885, 715));
+color(revPiston, dim); color(irrPiston, dim); stroke(revPiston, 5); stroke(irrPiston, 5);
+text(compareCaption, (540, 865), "Same endpoints · different entropy production");
+size(compareCaption, 28); color(compareCaption, dim);
+rect(revMeter, (300, 1120), 70, 260); rect(irrMeter, (780, 1120), 70, 260);
+outline(revMeter, dim); outline(irrMeter, dim); outlined(revMeter); outlined(irrMeter);
+stroke(revMeter, 3); stroke(irrMeter, 3);
+line(irrBar, (780, 1235), (780, 1235)); hue(irrBar, red, 0.72, 0.67); stroke(irrBar, 28);
+line(revZero, (278, 1235), (322, 1235)); hue(revZero, green, 0.58, 0.70); stroke(revZero, 5);
+equation(revEq, (300, 1325), `S_{\mathrm{gen}}=0`, 31);
+equation(irrEq, (780, 1325), `S_{\mathrm{gen}}>0`, 31);
+hue(revEq, green, 0.48, 0.70); hue(irrEq, red, 0.55, 0.68);
+
+tag(revHead, s5); tag(irrHead, s5); tag(revPanel, s5); tag(irrPanel, s5);
+tag(revGas, s5); tag(irrGas, s5); tag(revPiston, s5); tag(irrPiston, s5); tag(compareCaption, s5);
+tag(revMeter, s5); tag(irrMeter, s5); tag(irrBar, s5); tag(revZero, s5); tag(revEq, s5); tag(irrEq, s5);
+hidden(s5);
+
+// ---------------------------------------------------------------------------
+// 6 · THE ARROW OF TIME IS A STATISTICAL ARROW
+// ---------------------------------------------------------------------------
+
+rect(timeBox, (540, 610), 720, 310); outline(timeBox, dim); outlined(timeBox); stroke(timeBox, 3);
+particles(timeGas, timeBox, 63, 6, 211, "grid");
+hue(timeGas, hot, 0.48, 0.74); glow(timeGas, 0.7);
+arrow(timeForward, (300, 980), (780, 980)); hue(timeForward, red, 0.62, 0.69); stroke(timeForward, 5);
+equation(timeForwardLabel, (540, 1035), `t`, 28); color(timeForwardLabel, dim);
+arrow(timeReverse, (780, 980), (300, 980)); color(timeReverse, fg); stroke(timeReverse, 5); hidden(timeReverse);
+equation(timeReverseLabel, (540, 1035), `t`, 28); color(timeReverseLabel, dim); hidden(timeReverseLabel);
+text(timeCaption, (540, 1135), "A special state naturally spreads into a typical one");
+size(timeCaption, 29); hue(timeCaption, hot, 0.34, 0.74);
+equation(returnProb, (540, 285), `\Pr(\mathrm{return})=\frac{\Omega_{\mathrm{low}}}{\Omega_{\mathrm{eq}}}=e^{-\Delta S/k_B}`, 43);
+equation(returnOdds, (540, 365), `\Pr(\mathrm{ordered\ return})<10^{-40}`, 34);
+hue(returnOdds, hot, 0.48, 0.72); hidden(returnProb); hidden(returnOdds);
+
+tag(timeBox, s6); tag(timeGas, s6gas); tag(timeForward, s6); tag(timeForwardLabel, s6);
+tag(timeCaption, s6);
+tag(timeReverse, s6future); tag(timeReverseLabel, s6future);
+tag(returnProb, s6future); tag(returnOdds, s6future);
+hidden(s6); hidden(s6gas);
+
+circle(finalOrbit, (540, 790), 270); hidden(finalOrbit);
+for i in 0..72 {
+  let a = tau*i/72;
+  dot(finalDot{i}, (540 + 270*cos(a), 790 + 270*sin(a)), 4);
+  hue(finalDot{i}, 10 + 300*i/72, 0.54, 0.62);
+  glow(finalDot{i}, 0.5);
+  tag(finalDot{i}, finalRing);
+}
+equation(finalLaw, (540, 765), `\Delta S_{\mathrm{universe}}=S_{\mathrm{gen}}\ge 0`, 48);
+text(finalCaption, (540, 875), "Irreversible change produces entropy");
+size(finalCaption, 31); color(finalCaption, dim);
+hidden(finalRing); hidden(finalLaw); hidden(finalCaption);
+
+// ---------------------------------------------------------------------------
+// TIMELINE · six continuous beats, approximately 39 seconds
+// ---------------------------------------------------------------------------
+
+step("mixing") {
+  wait(5.5);
+  par {
+    seq { wait(0.45); fade(mixDivider, 0.20); }
+    seq { wait(0.55); arrange(mixCold, mixBox, "random", 0.95, out); wander(mixCold, 4.0); }
+    seq { wait(0.55); arrange(mixWarm, mixBox, "random", 0.95, out); wander(mixWarm, 4.0); }
+    seq {
+      wait(0.55);
+      par {
+        draw(mixCurve, 2.20, out);
+        travel(mixMarker, mixCurve, 2.20, out);
+        to(mixCount, value, 25.3, 2.20, out);
+      }
+    }
+  }
+}
+
+step("heat-flow") {
+  seq {
+    par {
+      fade(s1, 0.65);
+      show(mixToHeat, 0.10);
+      to(mixToHeat, morph, 1, 0.65, smooth);
+      seq { wait(0.20); show(s2, 0.45); }
+      rewrite(law, `\dot S_{\mathrm{tot}}=K\frac{(T_h-T_c)^2}{T_hT_c}>0`, 0.65, smooth);
+    }
+    par {
+      wander(hotMatter, 4.4);
+      wander(coldMatter, 4.4);
+      draw(flowCurve, 3.6, smooth);
+      travel(flowMarker, flowCurve, 3.6, smooth);
+      to(hotTemp, value, 400, 4.0, smooth);
+      to(coldTemp, value, 400, 4.0, smooth);
+      recolor(hotMatter, cyan, 4.0);
+      recolor(coldMatter, cyan, 4.0);
+      seq { flow(mixToHeat, 1.1); flow(mixToHeat, 1.1); flow(mixToHeat, 1.1); flow(mixToHeat, 1.1); }
+    }
+    wait(0.45);
+  }
+}
+
+step("free-expansion") {
+  seq {
+    par {
+      fade(s2, 0.65);
+      fade(mixToHeat, 0.25);
+      show(heatToExpand, 0.10);
+      to(heatToExpand, morph, 1, 0.65, smooth);
+      recolor(heatToExpand, dim, 0.65);
+      seq { wait(0.20); show(s3, 0.45); }
+      rewrite(law, `\Delta S=Nk_B\ln 2`, 0.65, smooth);
+    }
+    par {
+      seq { arrange(expandGas, expandBox, "random", 1.10, out); wander(expandGas, 1.45); }
+      fade(heatToExpand, 0.65);
+      draw(expandCurve, 2.45, smooth);
+      travel(expandMarker, expandCurve, 2.45, smooth);
+      to(expandCount, value, 20.9, 2.45, smooth);
+    }
+    wait(0.25);
+  }
+}
+
+step("heat-engine") {
+  seq {
+    par {
+      fade(s3, 0.65);
+      show(expandToEngine, 0.10);
+      to(expandToEngine, morph, 1, 0.65, smooth);
+      seq { wait(0.20); show(s4, 0.45); }
+      rewrite(law, `\frac{Q_h}{T_h}=\frac{|Q_c|}{T_c}`, 0.65, smooth);
+    }
+    par {
+      seq { draw(engineHotA, 1.85, smooth); draw(engineHotB, 3.35, smooth); }
+      seq { draw(engineColdA, 2.35, smooth); draw(engineColdB, 2.85, smooth); }
+      seq {
+        wait(0.15); show(engineDot, 0.15);
+        travel(engineDot, engineColdPath, 4.9, smooth);
+      }
+      fade(expandToEngine, 0.30);
+      seq { draw(qHot, 0.7); show(qHotLabel, 0.2); wait(1.0); }
+      seq { wait(1.3); draw(workArrow, 0.8); show(workLabel, 0.2); }
+      seq { wait(2.6); draw(qCold, 0.8); show(qColdLabel, 0.2); }
+    }
+    wait(2.15);
+  }
+}
+
+step("entropy-generation") {
+  seq {
+    par {
+      fade(s4, 0.50); fade(s4future, 0.50);
+      show(s5, 0.50);
+      rewrite(law, `\Delta S_{\mathrm{universe}}=S_{\mathrm{gen}}`, 0.50, smooth);
+    }
+    par {
+      arrange(revGas, revSmall, "grid", 2.4, smooth);
+      arrange(irrGas, irrSmall, "random", 2.4, smooth);
+      par { move(revPiston, (275, 505), 2.4, smooth); grow(revPiston, (275, 715), 2.4, smooth); }
+      par { move(irrPiston, (755, 505), 2.4, smooth); grow(irrPiston, (755, 715), 2.4, smooth); }
+      grow(irrBar, (780, 1025), 2.4, smooth);
+    }
+    wait(1.10);
+  }
+}
+
+step("time-arrow") {
+  seq {
+    par {
+      fade(s5, 0.50); fade(law, 0.50);
+      show(s6, 0.50); show(s6gas, 0.50);
+    }
+    par {
+      arrange(timeGas, timeBox, "random", 4.0, smooth);
+      seq { wait(3.0); pulse(timeForward, 0.8); }
+    }
+    wait(0.35);
+    par {
+      fade(timeForward, 0.30); fade(timeForwardLabel, 0.30);
+      show(timeReverse, 0.30); show(timeReverseLabel, 0.30);
+      say(timeCaption, "Exact reversal can reconstruct the past", 0.35);
+    }
+    arrange(timeGas, timeBox, "grid", 3.1, smooth);
+    par {
+      show(returnProb, 0.45); show(returnOdds, 0.45);
+      say(timeCaption, "But that reversal must be fantastically precise", 0.40);
+    }
+    wait(1.15);
+    par {
+      fade(s6, 0.90);
+      fade(s6future, 0.90);
+      arrange(timeGas, finalOrbit, "ring", 0.90, smooth);
+      seq { wait(0.55); fade(s6gas, 0.35); }
+      seq { wait(0.55); show(finalRing, 0.35); }
+      seq { wait(0.55); transform(finalRing, (540,790), 0.9511, -0.3090, 0.3090, 0.9511, 0.55, out); }
+      seq { wait(0.30); par { show(finalLaw, 0.60); show(finalCaption, 0.60); } }
+    }
+    wait(1.70);
+  }
+}

package/examples/series-parallel-springs.manic

@@ -0,0 +1,8 @@
+// series-parallel-springs.manic — same mass, springs in series vs parallel.
+title("Series vs parallel springs");
+canvas("16:9");
+text(hdr,(cx,44),"Same mass, same springs — series is soft (slow), parallel is stiff (fast)"); size(hdr,21); color(hdr,cyan); bold(hdr); display(hdr);
+seriesparallel(sp, (560,150), 68);
+timegraph(sp, (1060,320), 95);   // y_s(t) vs y_p(t): parallel oscillates faster
+text(cap,(cx,h-30),"parallel adds stiffness (k₁+k₂); series divides it (1/k = 1/k₁+1/k₂)"); size(cap,15); color(cap,dim); display(cap);
+run(sp, 11);

package/examples/serverless-processing.manic

@@ -0,0 +1,145 @@
+title("Serverless Event Processing — From Kafka to Cold Storage");
+canvas("16:9");
+template("neon");
+
+let u = (w+h-abs(w-h))/1440;
+watermark(mark, (w*0.15, h*0.055), "Made With Manic");
+text(kicker, (cx, h*0.055), "SERVERLESS · EVENT PROCESSING · MIXED STACK");
+text(headline, (cx, h*0.115), "Events in. Results, dead letters, and cold storage out.");
+text(caption, (cx, h*0.935), "Dashed relationships show every route the architecture allows.");
+size(kicker, 16*u); color(kicker, dim); bold(kicker);
+size(headline, 27*u); bold(headline); wrap(headline, w*0.88);
+size(caption, 18*u); color(caption, dim); wrap(caption, w*0.86);
+
+if h > 1.25*w {
+  architecture(pipeline, (cx, h*0.52), w*0.86, h*0.72);
+}
+else {
+  architecture(pipeline, (cx, h*0.52), w*0.94, h*0.70);
+}
+
+// --- the ingress + event source + a bold analytics tap (on-prem stack) ---
+cluster(ingest, pipeline, "INGEST");
+node(ingress, ingest, "onprem:fluentd", "logging");
+node(source, ingest, "onprem:kafka", "Event-Sourcing");
+node(spark, ingest, "onprem:spark", "Spark");
+
+cluster(flows, pipeline, "EVENT FLOWS");
+
+cluster(engines, flows, "DATA PROCESSING ENGINES");
+node(clicks, engines, "onprem:docker", "click stream");
+node(logins, engines, "onprem:docker", "user logins");
+node(analytics, engines, "onprem:docker", "data analytics");
+
+node(queue, flows, "aws:sqs", "results queue");
+node(dlq, flows, "aws:sqs", "Dead Letter Queue");
+
+cluster(processing, flows, "PROCESSING");
+node(persist, processing, "aws:lambda", "persist results");
+
+cluster(storage, flows, "STORAGE");
+node(store, storage, "aws:s3", "cold storage");
+node(dw, storage, "aws:redshift", "operational storage");
+
+// --- topology (Mingrammer edges) ---
+connect(parse, ingress, source);          // ingress >> Edge("parse") >> source
+connect(toSpark, source, spark);          // source >> Edge(bold) >> Spark
+connect(toEngines, source, engines);      // source >> workers
+connect(toQueue, engines, queue);         // workers >> queue
+connect(toHandlers, queue, processing);   // queue >> handlers
+connect(toDlq, queue, dlq, 120*u);        // queue >> dlq
+connect(toStore, processing, store);      // handlers >> store
+connect(toDw, processing, dw);            // handlers >> dw
+
+// --- colour every path by its RELATIONSHIP (cold dashed line + hot overlay) ---
+color(parse, cyan);        color(parse.hot, cyan);
+color(toEngines, cyan);    color(toEngines.hot, cyan);
+color(toQueue, cyan);      color(toQueue.hot, cyan);
+color(toHandlers, cyan);   color(toHandlers.hot, cyan);
+color(toSpark, magenta);   color(toSpark.hot, magenta);
+color(toStore, gold);      color(toStore.hot, gold);
+color(toDw, gold);         color(toDw.hot, gold);
+color(toDlq, red);         color(toDlq.hot, red);
+// legend
+text(legPipe, (w*0.24, h*0.175), "PIPELINE"); size(legPipe, 13); color(legPipe, cyan); bold(legPipe);
+text(legAna, (w*0.40, h*0.175), "ANALYTICS"); size(legAna, 13); color(legAna, magenta); bold(legAna);
+text(legStore, (w*0.58, h*0.175), "STORAGE"); size(legStore, 13); color(legStore, gold); bold(legStore);
+text(legDlq, (w*0.74, h*0.175), "DEAD-LETTER"); size(legDlq, 13); color(legDlq, red); bold(legDlq);
+hidden(legPipe); hidden(legAna); hidden(legStore); hidden(legDlq);
+message(event, source, "event");
+
+hidden(pipeline.nodes);
+hidden(ingest.parts); hidden(flows.parts); hidden(engines.parts); hidden(processing.parts); hidden(storage.parts);
+hidden(event.parts);
+untraced(parse); untraced(toSpark); untraced(toEngines); untraced(toQueue);
+untraced(toHandlers); untraced(toDlq); untraced(toStore); untraced(toDw);
+
+step("ingest") {
+  par {
+    show(ingest.parts, 0.45);
+    show(ingress, 0.40);
+    show(source, 0.40);
+    show(spark, 0.40);
+    say(caption, "Fluentd parses raw logs into Kafka; a bold tap also streams the source into Spark.", 0.40);
+  }
+}
+wait(0.20);
+
+step("event-flows") {
+  par {
+    show(flows.parts, 0.50);
+    show(engines.parts, 0.45);
+    stagger(0.10) { show(clicks, 0.35); show(logins, 0.35); show(analytics, 0.35); }
+    show(queue, 0.40); show(dlq, 0.40);
+    show(processing.parts, 0.45); show(persist, 0.40);
+    show(storage.parts, 0.45); show(store, 0.40); show(dw, 0.40);
+    say(caption, "Docker engines process the stream; a queue, a dead-letter queue, a Lambda, and storage complete it.", 0.40);
+  }
+}
+wait(0.20);
+
+step("possible-topology") {
+  par {
+    stagger(0.08) {
+      draw(parse, 0.4); draw(toEngines, 0.4); draw(toQueue, 0.4); draw(toHandlers, 0.4);
+      draw(toDlq, 0.4); draw(toStore, 0.4); draw(toDw, 0.4); draw(toSpark, 0.4);
+    }
+    show(legPipe, 0.3); show(legAna, 0.3); show(legStore, 0.3); show(legDlq, 0.3);
+    say(caption, "Every dashed edge is a possible relationship—not a claim that data is flowing.", 0.40);
+  }
+}
+wait(0.30);
+
+step("ingress-flow") {
+  par {
+    seq { flow(parse, 1.0); flow(toSpark, 1.0); }
+    say(caption, "Logging → parse → Kafka → Spark: the ingest-and-analytics tap.", 0.40);
+  }
+}
+wait(0.20);
+
+step("runtime-hot-path") {
+  par {
+    show(event.parts, 0.25);
+    hotpath(event, 6.0, 27);
+    say(caption, "One event chooses valid branches: Kafka → an engine → results queue → Lambda → storage.", 0.40);
+  }
+}
+wait(0.30);
+
+step("dead-letter") {
+  par {
+    flow(toDlq, 1.2);
+    say(caption, "Messages the handler cannot process are diverted to the dead-letter queue.", 0.40);
+  }
+}
+wait(0.30);
+
+step("takeaway") {
+  par {
+    pulse(flows.parts, 0.70);
+    pulse(event.parts, 0.60);
+    say(caption, "One mixed stack—on-prem ingest, serverless compute, cloud storage—stays readable end to end.", 0.45);
+  }
+}
+wait(1.40);

package/examples/shader-cellular.manic

@@ -0,0 +1,35 @@
+// shader-cellular — the Book-of-Shaders "Cellular noise" (Worley/Voronoi)
+// chapter. `voronoi(x,y)` scatters one feature point per unit cell and returns
+// the distance to the NEAREST one — so the field organises into cells: bright
+// near a point, dark at the equidistant borders. Drifting the coordinate in `t`
+// makes the cells flow. The 3×3 neighbour search runs inside the engine, so the
+// formula stays a closed-form, seekable function of (u, v, t) — no loop in the DSL.
+//
+//   manic examples/shader-cellular.manic
+title("Cellular noise — a Voronoi shader");
+canvas("9:16");
+template("black");
+
+shader(bg) {
+  let s = 5.5;
+  let d = voronoi(u*s*asp, v*s + t*0.4);    // distance to nearest cell point
+  let edge = smoothstep(0.0, 0.08, d);      // ~0 at borders → dark cracks
+  let tb = smoothstep(0.0, 0.14, v) * smoothstep(1.0, 0.86, v); // darken top/bottom so captions read
+  let hue = mod(d*200.0 + t*24.0, 360.0);   // colour by distance
+  let sat = 0.8;
+  let val = (0.15 + 0.7*edge) * tb;
+}
+
+caption(head, "Cellular noise", (540, 150), 34);
+caption(sub, "distance to the nearest of many scattered points", (540, 214), 20);
+hidden(head);
+hidden(sub);
+equation(eq, (540, 1720), `F_1(p)=\min_i\;\lVert p - q_i\rVert`, 34);
+hidden(eq);
+
+show(head);
+wait(1.4);
+show(sub);
+wait(2.4);
+show(eq);
+wait(22);

package/examples/shader-fractal.manic

@@ -0,0 +1,45 @@
+// shader-fractal — a LIVING Julia set. Each pixel iterates z = z² + c a fixed
+// number of times and colours by how fast it escapes — the Book-of-Shaders
+// "Fractals" chapter, but with NO per-pixel loop in the DSL: `julia(zx,zy,cx,cy)`
+// runs the iteration in the engine and returns an escape fraction in [0,1]. We
+// sweep the constant `c` in a circle over time, so the fractal morphs through the
+// whole Julia family — every frame still a pure function of `t` (scrub-safe).
+//
+//   manic examples/shader-fractal.manic
+title("A living Julia set — one formula per pixel");
+canvas("9:16");
+template("black");
+
+shader(bg) {
+  // complex plane, aspect-corrected and centred
+  let zx = (u - 0.5) * 3.0 * asp;
+  let zy = (v - 0.5) * 3.0;
+  // the constant c orbits slowly → the set continuously morphs
+  let cx = 0.7 * cos(t * 0.35);
+  let cy = 0.7 * sin(t * 0.35);
+  let e = julia(zx, zy, cx, cy);         // escape fraction: 1 = trapped, 0 = flees
+  let inside = step(0.985, e);           // 1 for the fractal body
+  let band = 0.5 + 0.5 * sin(e * 26.0 - t * 2.0); // rainbow escape contours
+  let glow = 1.0 - inside;               // dark body, lit exterior
+  let r = band * glow;
+  let g = (0.4 + 0.6 * band) * glow;
+  let b = (1.0 - 0.5 * band) * glow + inside * 0.06;
+}
+
+// ---- textbook annotations ----
+caption(head, "A living Julia set", (540, 150), 34);
+caption(sub, "z → z² + c, coloured by escape speed", (540, 214), 20);
+hidden(head);
+hidden(sub);
+equation(eq, (540, 1720), `z_{n+1} = z_n^2 + c`, 44);
+caption(lab, "no per-pixel loop in the DSL — the engine iterates", (540, 1800), 20);
+hidden(eq);
+hidden(lab);
+
+show(head);
+wait(1.4);
+show(sub);
+wait(2.4);
+show(eq);
+show(lab);
+wait(24);

package/examples/shader-fx.manic

@@ -0,0 +1,34 @@
+// shader-fx — the Layer-1 shader/formula helpers (fx kit) in action: `fill` and
+// `stroke` turn an SDF distance into a solid + an outline, `gain` shapes a gradient.
+// All scalar builtins, transpiled to GLSL with the CPU field as the exact fallback.
+//
+//   manic examples/shader-fx.manic
+title("fill · stroke · gain — SDF mask helpers");
+canvas("16:9");
+template("black");
+
+shader(fx) {
+  let x = u * asp;
+  let y = v;
+
+  // three shapes, unioned
+  let s0 = sdhexagon(x - 0.60, y - 0.5, 0.15);
+  let s1 = sdstar(x - 1.05, y - 0.5, 0.17, 5);
+  let s2 = sdcircle(x - 1.48, y - 0.5, 0.13);
+  let d = smin(smin(s0, s1, 0.01), s2, 0.01);
+
+  // masks from the distance
+  let fl = fill(d, 0.0, 0.004);          // 1 inside → 0 outside
+  let ol = stroke(d, 0.0, 0.03, 0.004);  // bright band on the iso-line
+
+  // gain-shaped vertical gradient behind the shapes
+  let bgv = gain(v, 2.2);
+  let base = 0.10 + 0.20 * bgv;
+
+  // compose: gradient bg, teal fill, white outline
+  let r = mix(mix(base, 0.16, fl), 1.0, ol);
+  let g = mix(mix(base, 0.52, fl), 1.0, ol);
+  let b = mix(mix(base * 1.7, 0.62, fl), 1.0, ol);
+}
+
+wait(4);