@maniclang/workbench 0.1.11

package/examples/limit.manic

@@ -0,0 +1,33 @@
+title("A limit — the value a curve heads toward");
+canvas("16:9");
+
+let ox = cx - 120;
+let oy = cy;
+
+text(hdr, (cx, 54), "sin(x) / x is undefined at 0 — but it heads straight for 1");
+size(hdr, 24); color(hdr, cyan); bold(hdr); display(hdr); hidden(hdr);
+
+axes(ax, (ox, oy), 620, 300, 1);
+color(ax, dim); untraced(ax);
+
+// sin(x)/x — a removable hole at x = 0, where the limit is 1
+plot(f, (ox, oy), 150, 220, "sin(x)/x", (-6.2, 6.2));
+color(f, cyan); stroke(f, 4); untraced(f);
+
+// the limit at x -> 0: open circle at (0, 1), guides, value, and an approaching dot
+limit(lim, f, 0);
+color(lim, gold);
+
+text(cap, (cx, h - 54), "slide the point in — f(x) closes on the open circle");
+size(cap, 20); color(cap, dim); display(cap); hidden(cap);
+
+// ---- timeline ----
+show(hdr, 0.6);
+draw(ax, 0.7);
+draw(f, 1.6);
+wait(0.3);
+show(lim, 0.5);
+show(cap, 0.4);
+wait(0.3);
+// walk the point toward x = 0 from the left — it approaches the open circle
+to(lim, x, 0, 3.5);

package/examples/linear-algebra-3d.manic

@@ -0,0 +1,50 @@
+// ============================================================================
+//  linear-algebra-3d.manic  —  Linear algebra in 3D (a lesson)
+// ----------------------------------------------------------------------------
+//  The 3-D companion to linear-algebra.manic. One matrix, two lenses, one
+//  orbiting stage:
+//     1. a 3x3 matrix TRANSFORMS space — the unit cube becomes a parallelepiped
+//        whose VOLUME is the determinant                          (linmap3)
+//     2. its EIGENVECTORS are the invariant axes that only stretch (eigen3)
+//
+//  Both use the same  A = [[1,0,0],[0,3,1],[0,1,3]]  (det = 8; eigenvalues 1,2,4),
+//  so the two views describe the very same matrix.
+// ============================================================================
+
+title("Linear algebra in 3D");
+canvas("16:9");
+
+camera3((12, 9.5, 10), (0.4, 1.6, 1.6), 40);
+grid3(floor, (0, 0, 0), 4, 1); color(floor, dim); opacity(floor, 0.3);
+
+// A = [[1,0,0],[0,3,1],[0,1,3]]  — det 8, eigenvalues 1, 2, 4
+linmap3(lm, (0, 0, 0), 1, 0, 0, 0, 3, 1, 0, 1, 3);
+eigen3(ev, (0, 0, 0), 1, 0, 0, 0, 3, 1, 0, 1, 3);
+// the eigen-axes wait until chapter 2
+hidden(ev.axis0); hidden(ev.axis1); hidden(ev.axis2);
+hidden(ev.l0); hidden(ev.l1); hidden(ev.l2);
+
+text(cap, (cx, h - 46), ""); size(cap, 22); color(cap, dim); display(cap);
+
+// ---- 1. the matrix as a transformation of space ----
+section("A matrix in 3D");
+say(cap, "a 3x3 matrix sends the unit cube to a parallelepiped — its columns", 0.5);
+orbit3(50, 26, 13, 4, smooth);
+say(cap, "the volume it encloses is the determinant: det = 8, so space grew 8x", 0.5);
+orbit3(116, 30, 13, 4, smooth);
+// clear the transformation view
+fade(lm, 0.6); fade(lm.ref, 0.6);
+fade(lm.i, 0.6); fade(lm.j, 0.6); fade(lm.k, 0.6);
+fade(lm.li, 0.6); fade(lm.lj, 0.6); fade(lm.lk, 0.6); fade(lm.val, 0.6);
+wait(0.3);
+
+// ---- 2. the same matrix, through its eigenvectors ----
+say(cap, "", 0.2);
+section("Eigenvectors");
+say(cap, "three special directions only STRETCH when A acts — the eigenvectors", 0.5);
+show(ev.axis0, 0.5); show(ev.axis1, 0.5); show(ev.axis2, 0.5);
+show(ev.l0, 0.4); show(ev.l1, 0.4); show(ev.l2, 0.4);
+orbit3(58, 24, 7, 4, smooth);
+say(cap, "their stretch factors are the eigenvalues: 1, 2 and 4", 0.5);
+orbit3(122, 32, 6.5, 4.5, smooth);
+wait(0.5);

package/examples/linear-algebra.manic

@@ -0,0 +1,115 @@
+// ============================================================================
+//  linear-algebra.manic  —  Linear Algebra in five ideas (a lesson)
+// ----------------------------------------------------------------------------
+//  A guided tour of the whole subject, not a feature demo. One stage, five
+//  chapters; chapters 1-3 view the SAME matrix A = [[2,1],[1,2]] through three
+//  lenses, so the ideas connect:
+//     1. a matrix TRANSFORMS space          (linmap)
+//     2. the DETERMINANT is how area scales (determinant)   -> det = 3
+//     3. EIGENVECTORS only stretch          (diagonalise)   -> lambda = 3, 1
+//     4. SOLVING A x = b                     (linsolve -> rref)
+//     5. PROJECTION: the closest answer     (project)
+//
+//  Reveal recipe (works for lines, arrows, fills, and text alike, preserving
+//  each element's opacity): `untraced(tag)` at build time, `draw(tag)` to reveal,
+//  `fade(tag)` to clear before the next chapter. `tag` broadcasts to every entity
+//  carrying it (see the ergonomics in the manic guide).
+// ============================================================================
+
+title("Linear Algebra, in five ideas");
+canvas("16:9");
+
+let sx = cx;
+let sy = cy + 44;   // shared stage center
+let u = 44;
+
+text(cap, (cx, h - 46), ""); size(cap, 22); color(cap, dim); display(cap);
+
+// ---- build every chapter's visual up front, drawn-blank (untraced) ----
+// A coordinate grid draws in with each chapter for consistent visual feedback.
+// Chapters 1 & 3 bring their own (the deformed grid / the eigen-grid); chapters
+// 2, 4, 5 get a plain reference grid that traces in at the start of the section.
+plane(g2, (sx, sy), 176, 176, u); untraced(g2);   // determinant — count the cells
+plane(g4, (sx, sy), 240, 230, u); untraced(g4);   // solving — read off (1, 3)
+plane(g5, (sx, sy), 200, 200, u); untraced(g5);   // projection
+
+// 1. transformation of A = [[2,1],[1,2]]
+linmap(lm, (sx, sy), u, 2, 1, 1, 2);
+untraced(lm);
+
+// 2. determinant of the same A (parallelogram is the bare id `dt`)
+determinant(dt, (sx, sy), u, 2, 1, 1, 2);
+untraced(dt); untraced(dt.unit); untraced(dt.val);
+
+// 3. eigenvectors / diagonalisation of the same A
+diagonalise(dg, (sx, sy), u, 2, 1, 1, 2);
+untraced(dg);
+
+// 4a. a 2x2 system as two lines (solution dot is the bare id `sys`)
+linsolve(sys, (sx, sy), u, 2, 1, 1, 3, 5, 10);
+untraced(sys.r1); untraced(sys.r2); hidden(sys); hidden(sys.val);
+// 4b. the same system reduced by elimination
+rref(rr, "2 1 5 ; 1 3 10", (sx, sy - 24), 120, 60);
+untraced(rr.lbrack); untraced(rr.rbrack);
+
+// 5. projection of a vector onto a line
+project(pj, (sx, sy), u, (1, 3), (3, 1));
+untraced(pj);
+
+// ============================  the lesson  ==================================
+
+section("Transformations");
+draw(lm, 1.2);
+say(cap, "a matrix sends every point to a new one — and it does so LINEARLY", 0.5);
+wait(1.8);
+say(cap, "the grid stays parallel and evenly spaced; i-hat, j-hat land on its columns", 0.5);
+wait(2.2);
+fade(lm, 0.6);
+wait(0.3);
+
+say(cap, "", 0.2);
+section("The determinant");
+draw(g2, 0.7);
+draw(dt.unit, 0.5); draw(dt, 0.7); draw(dt.val, 0.4);
+say(cap, "how much does it stretch area? the unit square becomes this parallelogram", 0.5);
+wait(2.0);
+say(cap, "that area IS the determinant = 3 — three grid cells; a flip would be negative", 0.5);
+wait(2.2);
+fade(dt, 0.6); fade(dt.unit, 0.6); fade(dt.val, 0.6); fade(g2, 0.6);
+wait(0.3);
+
+say(cap, "", 0.2);
+section("Eigenvectors");
+draw(dg, 1.2);
+say(cap, "most vectors change direction — but a few only STRETCH: the eigenvectors", 0.5);
+wait(2.2);
+say(cap, "in their basis A is pure scaling:  A = P D P^-1,  D = diag(3, 1)", 0.5);
+wait(2.2);
+fade(dg, 0.6);
+wait(0.3);
+
+say(cap, "", 0.2);
+section("Solving  A x = b");
+draw(g4, 0.7);
+draw(sys.r1, 0.7); draw(sys.r2, 0.7);
+show(sys, 0.4); show(sys.val, 0.4);
+say(cap, "a system of equations is a set of lines; the solution is where they meet", 0.5);
+wait(2.2);
+fade(sys, 0.5); fade(sys.r1, 0.5); fade(sys.r2, 0.5); fade(sys.val, 0.5); fade(g4, 0.5);
+say(cap, "elimination finds it by reducing [ A | b ] to the identity beside the answer", 0.5);
+draw(rr.lbrack, 0.4); draw(rr.rbrack, 0.4);
+show(rr.s0, 0.4); show(rr.op0, 0.3);
+wait(1.6);
+par { show(rr.s4, 0.5); fade(rr.s0, 0.5); } show(rr.op4, 0.4); fade(rr.op0, 0.3);
+wait(2.0);
+fade(rr.s4, 0.5); fade(rr.op4, 0.4); fade(rr.lbrack, 0.4); fade(rr.rbrack, 0.4);
+wait(0.3);
+
+say(cap, "", 0.2);
+section("Projection");
+draw(g5, 0.7);
+draw(pj, 1.0);
+say(cap, "when no exact answer exists, take the CLOSEST point of the subspace", 0.5);
+wait(2.0);
+say(cap, "the error is perpendicular — that principle IS least-squares, the best fit", 0.5);
+wait(2.4);

package/examples/linear-map.manic

@@ -0,0 +1,39 @@
+title("What a matrix does to space");
+canvas("16:9");
+
+let ox = cx - 60;
+let oy = cy + 40;
+
+text(hdr, (cx, 54), "the matrix [[2,1],[1,2]] — grid, determinant, eigenvectors");
+size(hdr, 24); color(hdr, cyan); bold(hdr); display(hdr); hidden(hdr);
+
+text(cap, (cx, h - 50), "");
+size(cap, 22); color(cap, dim); display(cap);
+
+// the plane deformed by the matrix (î, ĵ land on its columns)
+linmap(lm, (ox, oy), 46, 2, 1, 1, 2, 2);
+
+// the unit square's image — area = determinant
+determinant(dt, (ox, oy), 46, 2, 1, 1, 2);
+hidden(dt); hidden(dt.unit); hidden(dt.val);
+
+// the two invariant directions (eigenvectors)
+eigen(ev, (ox, oy), 46, 2, 1, 1, 2);
+hidden(ev); hidden(ev.l0); hidden(ev.l1);
+
+// ---- timeline ----
+show(hdr, 0.6);
+say(cap, "the matrix bends the grid; i-hat and j-hat land on its columns", 0.5);
+wait(1.4);
+
+say(cap, "the unit square maps to a parallelogram — its area IS the determinant", 0.5);
+show(dt, 0.6);
+show(dt.unit, 0.4);
+show(dt.val, 0.5);
+wait(1.4);
+
+say(cap, "two directions only stretch, never turn: the eigenvectors", 0.5);
+show(ev, 0.6);
+show(ev.l0, 0.4);
+show(ev.l1, 0.4);
+wait(1.0);

package/examples/linear-map3.manic

@@ -0,0 +1,33 @@
+// ============================================================================
+//  linear-map3.manic  —  a 3x3 matrix, in 3D (the 3-D echo of linear-map)
+// ----------------------------------------------------------------------------
+//  `linmap3(id, (cx,cy,cz), a,b,c,d,e,f,g,h,i, [color])` applies the 3x3 matrix
+//  [[a,b,c],[d,e,f],[g,h,i]] to space: the unit cube (faint wireframe) becomes a
+//  parallelepiped, with basis arrows i/j/k landing on the matrix's COLUMNS. The
+//  volume it encloses IS the determinant (labelled) — it flips colour when the
+//  determinant is negative (orientation reversed) and collapses flat at det = 0.
+//
+//  TO ADAPT: change the nine numbers. Try a shear (1,0.6,0, 0,1,0, 0,0,1) → det 1
+//  (volume unchanged), or swap two columns to make det negative (a reflection).
+// ============================================================================
+
+title("A 3x3 matrix, in 3D");
+canvas("16:9");
+
+camera3((7, 5.5, 6), (1, 1, 1), 40);
+grid3(floor, (0, 0, 0), 4, 1); color(floor, dim); opacity(floor, 0.4);
+
+// M = [[1.5,0.5,0],[0,1.5,0.5],[0.5,0,1.5]]  — a skew + stretch, det = 3.5
+linmap3(lm, (0, 0, 0), 1.5, 0.5, 0, 0, 1.5, 0.5, 0.5, 0, 1.5);
+
+text(cap, (cx, h - 46), ""); size(cap, 22); color(cap, dim); display(cap);
+
+say(cap, "a 3x3 matrix sends the unit cube to a parallelepiped", 0.5);
+orbit3(58, 26, 10, 4, smooth);
+
+say(cap, "i, j, k land on its columns — where the three axes are sent", 0.5);
+orbit3(116, 32, 10, 4, smooth);
+
+say(cap, "the volume enclosed IS the determinant: det = 3.5, so space grew 3.5x", 0.5);
+orbit3(60, 20, 9, 4.5, smooth);
+wait(0.5);

package/examples/linear-system.manic

@@ -0,0 +1,99 @@
+// ============================================================================
+//  linear-system.manic  —  the geometry of solving & spanning (a template)
+// ----------------------------------------------------------------------------
+//  Three side-by-side panels, each built up with animation:
+//    A) a 2x2 system as two lines meeting at the solution        (linsolve)
+//    B) two independent vectors spanning the whole plane         (span)
+//    C) two parallel vectors collapsing to a single line, rank 1 (span)
+//
+//  HOW TO ADAPT THIS FILE:
+//    * Change the system in panel A: linsolve(sys, center, unit, a,b,c,d, e,f)
+//      draws  a*x + b*y = e  and  c*x + d*y = f, meeting at the solution.
+//    * Change the vectors in panels B/C: span(id, center, unit, (vx,vy),(wx,wy)).
+//    * Everything is positioned from cx/cy/w/h + a per-panel origin (ax/bx/dx)
+//      and a `unit` = pixels-per-grid-step, so it scales cleanly. Grid point
+//      (gx,gy) maps to screen (origin_x + gx*u, origin_y - gy*u)  [math y-up].
+//    * OPTIONAL: shade the closed region the two lines bound with the axes —
+//      see the commented `polygon(feasible, ...)` block in Panel A below.
+// ============================================================================
+
+title("Solving & spanning, visually");
+canvas("16:9");
+
+let y0 = cy + 20;   // shared vertical center of the three panels
+let ax = 280;       // panel A origin x — a system as two lines
+let bx = 640;       // panel B origin x — span = the whole plane
+let dx = 1000;      // panel C origin x — parallel vectors collapse to a line
+let u = 24;         // pixels per grid unit (shared scale)
+
+text(hdr, (cx, 46), "linear algebra: the geometry of solving & spanning");
+size(hdr, 24); color(hdr, cyan); bold(hdr); display(hdr);
+
+// per-panel captions, revealed as each panel animates
+text(la, (ax, 96), "a system = two lines"); size(la, 18); color(la, dim); display(la); hidden(la);
+text(lb, (bx, 96), "span of two vectors"); size(lb, 18); color(lb, dim); display(lb); hidden(lb);
+text(lc, (dx, 96), "parallel = rank 1"); size(lc, 18); color(lc, dim); display(lc); hidden(lc);
+
+// faint coordinate backdrops (drawn once, static)
+plane(pa, (ax, y0), 150, 190, u);
+plane(pb, (bx, y0), 150, 190, u);
+plane(pc, (dx, y0), 150, 190, u);
+
+// ---- Panel A — the system 2x + y = 5 and x + 3y = 10, meeting at (1, 3) ----
+linsolve(sys, (ax, y0), u, 2, 1, 1, 3, 5, 10);
+untraced(sys.r1); untraced(sys.r2);   // start blank, drawn in on the timeline
+hidden(sys); hidden(sys.val);         // the solution dot + its label fade in
+
+// -- OPTIONAL: fill the closed area the two lines bound with the axes --------
+//  The two rows, the x-axis and the y-axis enclose a quadrilateral (the classic
+//  "feasible region"). Its corners, in grid coordinates, are:
+//     (0,0)  ->  (2.5,0)  ->  (1,3)  ->  (0,3.33)
+//   origin   line1 hits   the two   line2 hits
+//            the x-axis   lines meet the y-axis
+//  Uncomment to shade it (points are origin + gridX*u, origin - gridY*u):
+//
+// polygon(feasible,
+//   (ax,            y0),           // (0, 0)     the origin
+//   (ax + 2.5*u,    y0),           // (2.5, 0)   line 1 crosses the x-axis
+//   (ax + u,        y0 - 3*u),     // (1, 3)     the two lines meet
+//   (ax,            y0 - 3.333*u), // (0, 3.33)  line 2 crosses the y-axis
+//   lime);
+// opacity(feasible, 0.18);         // translucent, so grid + lines show through
+// z(feasible, -1);                 // sit behind the lines
+//   (for an animated reveal instead of a static fill, also `hidden(feasible);`
+//    above, then `to(feasible, opacity, 0.18, 0.6);` in Panel A's timeline.)
+// ---------------------------------------------------------------------------
+
+// ---- Panel B — two independent vectors reach every point: the whole plane --
+span(fill, (bx, y0), u, (3, 1), (-1, 2));
+untraced(fill.v); untraced(fill.w);   // vectors draw in
+hidden(fill.plane);                   // faint region fades to 0.14
+
+// ---- Panel C — two parallel vectors only reach one line: rank 1 ------------
+span(rank, (dx, y0), u, (2, 1), (-2, -1), gold);
+untraced(rank.v); untraced(rank.w); untraced(rank.line);
+
+text(cap, (cx, h - 44), ""); size(cap, 22); color(cap, dim); display(cap);
+
+// ---- Panel A timeline: two lines draw in, then the solution pops -----------
+show(la, 0.4);
+say(cap, "two equations are two lines; where they cross solves the system", 0.5);
+par { draw(sys.r1, 0.8); draw(sys.r2, 0.8); }
+show(sys, 0.4);
+show(sys.val, 0.4);
+pulse(sys);
+wait(1.6);
+
+// ---- Panel B timeline: two vectors grow out, then the plane fills in -------
+show(lb, 0.4);
+say(cap, "two independent vectors combine to reach every point: the whole plane", 0.5);
+par { draw(fill.v, 0.7); draw(fill.w, 0.7); }
+to(fill.plane, opacity, 0.14, 0.9);
+wait(1.6);
+
+// ---- Panel C timeline: two parallel vectors, then their line (collapse) ----
+show(lc, 0.4);
+say(cap, "but parallel vectors only reach one line: rank 1, a collapse", 0.5);
+par { draw(rank.v, 0.7); draw(rank.w, 0.7); }
+draw(rank.line, 0.8);
+wait(1.8);

package/examples/linear_transform.manic

@@ -0,0 +1,43 @@
+// Linear Transformation — a 2x2 matrix bends the whole plane. The grid, the
+// basis vectors i-hat / j-hat, and a sample point all carry the tag `pl`, so a
+// single `transform` applies the matrix to everything at once (Manim's
+// ApplyMatrix). Straight lines stay straight; the grid shears / rotates.
+//
+//   manic examples/linear_transform.manic
+//   manic examples/linear_transform.manic --template blueprint
+
+title("Linear Transformation");
+canvas("16:9");
+
+let ox = cx;   let oy = cy;
+
+text(head, (cx, 84), "a matrix bends the whole plane -- watch the grid");
+display(head);  color(head, cyan);  size(head, 24);  hidden(head);
+text(cap, (cx, 672), "");  color(cap, dim);  size(cap, 23);
+
+// the plane (its grid + axes are all tagged `pl`)
+plane(pl, (ox, oy), 580, 320, 60);
+// basis vectors + a sample point, all tagged `pl` so they transform together
+vector(vi, (ox, oy), (120, 0), cyan);      stroke(vi, 4);   tag(vi, pl);
+vector(vj, (ox, oy), (0, -120), magenta);  stroke(vj, 4);   tag(vj, pl);
+dot(mark, (ox + 180, oy - 100), 9);  color(mark, lime);  glow(mark, 1.6);  tag(mark, pl);
+
+// --- script ---
+show(head, 0.5);
+say(cap, "the identity grid, with i-hat (cyan) and j-hat (magenta)");
+wait(0.7);
+
+section("Shear");
+say(cap, "shear: i-hat stays put, j-hat leans over");
+transform(pl, (ox, oy), 1, 0.5, 0, 1, 1.4, smooth);
+wait(0.8);
+
+section("Undo");
+say(cap, "the inverse matrix brings it right back");
+transform(pl, (ox, oy), 1, -0.5, 0, 1, 1.4, smooth);
+wait(0.6);
+
+section("Rotate");
+say(cap, "a rotation matrix turns the whole plane");
+transform(pl, (ox, oy), 0.707, -0.707, 0.707, 0.707, 1.5, smooth);
+wait(1.3);

package/examples/linked_list.manic

@@ -0,0 +1,38 @@
+// Linked List — classic anatomy, three variations. A node is a framed box split
+// into compartments: singly `[ data | .next ]`, doubly `[ .prev | data | next. ]`,
+// where a pointer field carries a dot its arrow starts from. `head` marks the
+// entry node; the tail's `next` ends at `NULL` (singly/doubly) or curves back to
+// the head (circular). `insert`/`remove` re-thread the pointers — no shifting.
+//
+//   manic examples/linked_list.manic
+
+title("Linked List");
+canvas("16:9");
+
+text(head, (cx, 56), "node = data + pointer field(s); head in, NULL or loop at the tail");
+display(head);  color(head, cyan);  size(head, 24);  hidden(head);
+text(cap, (cx, 700), "");  color(cap, dim);  size(cap, 24);
+
+text(t1, (150, 160), "singly");    color(t1, lime);   size(t1, 22);
+text(t2, (150, 350), "doubly");    color(t2, lime);   size(t2, 22);
+text(t3, (150, 545), "circular");  color(t3, lime);   size(t3, 22);
+
+list(sa, "3 8 5", (cx, 160), singly, 64, 50);
+list(da, "3 8 5", (cx, 350), doubly, 64, 50);
+list(ca, "3 8 5", (cx, 545), circular, 64, 50);
+
+show(head, 0.5);
+say(cap, "three classic variations of the same idea");
+wait(0.9);
+
+section("Insert");
+say(cap, "insert 7 after node 1 in the doubly list — pointers re-thread, no shift");
+insert(da, 1, "7");
+wait(0.6);
+
+section("Remove");
+say(cap, "remove the head of the singly list — the list re-points past it");
+remove(sa, 0);
+
+say(cap, "data + pointers: the whole family from one primitive");
+wait(1.4);

package/examples/lln.manic

@@ -0,0 +1,31 @@
+// ============================================================================
+//  lln.manic  —  the Law of Large Numbers (stats Tier 3)
+// ----------------------------------------------------------------------------
+//  `lln(id, (cx,cy), trials, [seed], [width], [height])` plots the running
+//  proportion of heads over many coin flips: wild at first, settling onto the
+//  true 0.5. Draws `{id}.curve`, the reference line `{id}.ref`, axis labels, and
+//  the final value. Seeded → the render is identical every time.
+//
+//  TO ADAPT: change `trials` (more → tighter settling) or `seed` (a different
+//  reproducible run).
+// ============================================================================
+
+title("The Law of Large Numbers");
+canvas("16:9");
+
+lln(ll, (cx, cy + 10), 600, 3, 720, 300);
+untraced(ll.curve);              // the proportion traces in — watch it settle
+hidden(ll.finallbl);
+hidden(ll.truelbl);
+
+text(cap, (cx, h - 46), ""); size(cap, 22); color(cap, dim); display(cap);
+
+say(cap, "flip a fair coin over and over; track the proportion of heads so far", 0.5);
+show(ll.truelbl, 0.4);
+wait(0.8);
+say(cap, "early on it swings wildly — a few flips prove nothing", 0.5);
+draw(ll.curve, 2.6);
+wait(0.4);
+say(cap, "but over many trials it settles onto the true probability, 0.5", 0.5);
+show(ll.finallbl, 0.4);
+wait(1.9);

package/examples/loop-cinematic.manic

@@ -0,0 +1,41 @@
+// ============================================================================
+//  loop-cinematic.manic  —  the loop-the-loop as a movie (real physics inside)
+// ----------------------------------------------------------------------------
+//  Same recipe as bullet-impact: build the real `looptrack` sim, aim the camera,
+//  sync the beats to the physics. A ball is released, races down the ramp, and
+//  the camera pushes in as it climbs the loop — the tension is REAL (it genuinely
+//  slows at the top, energy traded for height), then it clears and rockets out.
+// ============================================================================
+
+title("Loop the Loop");
+canvas("16:9");
+
+// the real curved-track physics — a modest release height, so it BARELY clears
+// the top (H just over 2·r) — that's where the real tension lives
+looptrack(lt, (500, 560), 1, 2.4, 95);
+hidden(lt);
+
+text(cap, (cx, h - 46), ""); color(cap, fg); size(cap, 24); bold(cap); display(cap); sticky(cap);
+
+// ================= THE SCENE =================
+cam((420, 400), 0.4, smooth);            // frame the whole ramp + loop
+say(cap, "release…", 0.4);
+show(lt, 0.5);
+wait(0.4);
+
+// down the ramp, into the loop — the camera pushes in for the climb
+par {
+  run(lt, 6.0);
+  seq {
+    say(cap, "released — down the ramp!", 0.3);
+    par { cam((500, 455), 3.0, smooth); zoom(1.35, 3.0, smooth); }   // slow push through the descent + entry
+    say(cap, "up and over — will it clear the top?!", 0.3);
+    wait(1.7);                                                        // the climb + the crawl over the top
+    say(cap, "…MADE IT!", 0.25);
+    par { cam((470, 410), 1.3, smooth); zoom(1.1, 1.3, smooth); }     // ease back as it rockets out
+  }
+}
+
+// the physics was the whole story
+say(cap, "…real energy: fastest at the bottom, barely crawling over the top", 0.4);
+wait(1.0);

package/examples/loop-track.manic

@@ -0,0 +1,11 @@
+// loop-track.manic — a ball rolls down a ramp and around a vertical loop-the-loop.
+// `looptrack(id,[center],[radius],[height],[unit])`. A curved-track energy solver:
+// v = √(2g(H−y)) along the arc, so the ball visibly SLOWS at the top. The release
+// height must exceed 2·radius to clear the top. `energygraph` shows KE↔PE.
+title("Loop-the-loop — down the ramp, around the loop");
+canvas("16:9");
+text(hdr, (cx, 44), "Release high enough (H > 2r) and the ball clears the top of the loop"); size(hdr, 21); color(hdr, cyan); bold(hdr); display(hdr);
+looptrack(lt, (470, 560), 1, 3);
+energygraph(lt, (1010, 330), 120);
+text(cap, (cx, h - 32), "energy conserved: it trades kinetic for potential, slowest at the top of the loop"); size(cap, 15); color(cap, dim); display(cap);
+run(lt, 5);

package/examples/lorenz-attractor.manic

@@ -0,0 +1,55 @@
+// lorenz-attractor — the classic strange attractor, drawn by the new
+// `trajectory3`: a 3-D ODE integrated with RK4 into a single stateful path, hued
+// by speed and orbited by the camera. This is NOT a `cloud` (those are pure
+// f(i,t) fields with no memory); an attractor is a recurrence — each point
+// depends on every step before it — which is exactly what `trajectory3` adds.
+//
+// The Lorenz system (Edward Lorenz, 1963): ẋ=σ(y−x), ẏ=x(ρ−z)−y, ż=xy−βz,
+// with σ=10, ρ=28, β=8/3 — the birthplace of "the butterfly effect". Reproduced
+// from a p5 art-tweet by @yuruyurau (https://x.com/yuruyurau); our own 3-D,
+// speed-hued, annotated take.
+//
+//   manic examples/lorenz-attractor.manic
+title("The Lorenz attractor");
+canvas("9:16");
+template("black");
+
+camera3((10, -10, 6), (0, 0, 0), 30, perspective);
+
+// integrate the 3-D flow with RK4; coloured by speed automatically
+trajectory3(butterfly,
+  "10*(y - x)",          // ẋ = σ(y − x)
+  "x*(28 - z) - y",      // ẏ = x(ρ − z) − y
+  "x*y - 2.667*z",       // ż = xy − βz
+  (0.1, 0, 0), 13000);
+untraced(butterfly);
+
+// ---- textbook annotations ----
+caption(head, "The Lorenz attractor", (540, 150), 40);
+caption(sub, "deterministic chaos — one 3D flow", (540, 220), 24);
+hidden(head);
+hidden(sub);
+equation(eq, (540, 1660),
+  `\dot x=\sigma(y{-}x),\;\; \dot y=x(\rho{-}z){-}y,\;\; \dot z=xy-\beta z`, 26);
+caption(lab, "σ=10, ρ=28, β=8/3 — integrated by RK4", (540, 1746), 22);
+hidden(eq);
+hidden(lab);
+
+// ---- run it: the path draws on while the camera orbits, annotations reveal ----
+par {
+  seq {
+    orbit3(45, 26, 11, 0.05, linear);       // snap to a start view
+    orbit3(405, 26, 11, 22, linear);        // then a full slow revolution
+  }
+  draw(butterfly, 12);                        // the attractor traces itself on
+  seq {
+    wait(0.6);
+    show(head);
+    wait(1.6);
+    show(sub);
+    wait(2.0);
+    show(eq);
+    show(lab);
+    wait(25);
+  }
+}

package/examples/lorenz-shells.manic

@@ -0,0 +1,43 @@
+// lorenz-shells — the Lorenz attractor through a different lens, via the same
+// `cloud … from flow(...)` bridge (σ=9, ρ=28, β=2). `flow` integrates the 3D ODE
+// and hands each of 30,000 points the i-th state as hx/hy/hz; the cloud projects
+// (hx, hz) through a polar lens fanned into 3 layers (mod i,3) into flowing shell
+// forms. One bridge, endless dynamical-system art.
+//
+// Original idea by @yuruyurau (https://x.com/yuruyurau). Our hue'd, annotated
+// take on a 9:16 Short — pure in (i, t), so it scrubs and records.
+//
+//   manic examples/lorenz-shells.manic
+title("The Lorenz flow, in shells");
+canvas("9:16");
+template("black");
+
+cloud(shells, 30000, #ffffff, 0.55)
+  from flow("9*(y - x)", "x*(28 - z) - y", "x*y - 2*z", (6, 6, 6), 0.001) {
+  let q = hx*(sin(t*pi/80 - hx*hx/89 + mod(i,3))*0.8 + 1.2)*2 + 99;
+  let k = hz/39 + t*pi/960 + mod(i,3)*2;
+  let px = q*sin(k);
+  let py = q*cos(k);
+  let grow = tanh(t*0.5 + 0.12);
+  let x = 540 + px * 2.2 * grow;
+  let y = 960 + py * 2.2 * grow;
+  let hue = mod(mod(i,3)*90 + hz*4 + t*14, 360);
+}
+
+// ---- textbook annotations ----
+caption(head, "The Lorenz flow, in shells", (540, 140), 36);
+caption(sub, "integrate chaos, then project it", (540, 208), 22);
+hidden(head);
+hidden(sub);
+equation(eq, (540, 1706), `\dot x=\sigma(y{-}x),\;\; \dot y=x(\rho{-}z){-}y,\;\; \dot z=xy-\beta z`, 24);
+caption(lab, "same flow as lorenz-attractor, a new lens", (540, 1786), 20);
+hidden(eq);
+hidden(lab);
+
+show(head);
+wait(1.4);
+show(sub);
+wait(2.6);
+show(eq);
+show(lab);
+wait(20);